Mark's Project Blog

DPS Bot

Fri, 08 May 2026 20:43:19 -0400

So I decided to build a bot in Mastodon that reports the damage you’re taking hourly.

This was a fun exercise and mostly an excuse to play with Rust. I’ll talk about the process a bit: the core, setting up the scripts to execute it, and then a Docker wrapper.

Documenting Your Org's Files

Sat, 02 May 2026 12:34:45 -0400

I’ve been thinking as of late about the things that desktop computer users get that we’ve decided isn’t worth giving software engineers in their own infrastructure.

I don’t think I’ve ever met anyone who works at a big tech company who is happy with the status quo. The closest we get is less sad. And a lot of the pain points are fixable, but nobody fixes them because they aren’t key business needs. Setting aside, for now, the conversation of what that means (happy engineers are more often than not more productive engineers), I’m going to document some basic quality-of-life improvements as they come to mind and provide some easy and more complicated suggestions for improving them.

Screenshots into emacs org files in Windows

Sat, 02 Aug 2025 21:28:58 -0400

Related to my previous post, I needed to resolve the need to quickly take screenshots from Windows and put them in an org file in emacs. This proved a bit more difficult than I’d hoped; triggering a screenshot in Windows from emacs is non-obvious, and my attempts to use yank-media suggested that screenshots didn’t end up on the clipboard in a way emacs could see them. Other options I could find in melpa knew how to screenshot from XWindows, but not Windows.

I Cannot Recommend Etherpad on Sandstorm at This Time

Sat, 02 Aug 2025 15:40:19 -0400

Lately, I’ve been using Etherpad on Sandstorm to track notes and clues in the game Blue Prince. While it started okay, I cannot recommend it at this time for this application. What follows is the specific issues that I’ve encountered.

Note that this may not mean it’s not fit for any purpose, or that these things cannot be fixed (I haven’t figured out how to fix them). But here are the issues I’ve encountered, and then I’ll talk about what I’m doing instead.

Monitoring Home Network With Grafana, Loki, Prometheus, and Alloy in Docker (part 2)

Mon, 28 Jul 2025 22:47:25 -0400

In part 1, we discussed setting up Grafana, Loki, and Alloy. Here, we’ll dive into Prometheus setup.

Prometheus differs from Loki in that Loki stores individual log entries. Prometheus is a time-series database: it stores individual events (each of which can be tagged with specific labels) and it is specialized for running analysis, bucketing, and summaries on events.

It’s unfortunate that we can’t use one datastore for both types of data, but that’s the tradeoff of using a bit more scalable / extensible framework; we have two datastores because they are specialized to store two kinds of data (and if you have a large deployment, they may even have two different scaling concerns!).

The steps here, relative to what we’ve built, are pretty straightforward:

Monitoring Home Network With Grafana, Loki, Prometheus, and Alloy in Docker (part 1)

Wed, 25 Jun 2025 09:53:52 -0400

Having gotten to three whole nodes in my home network, I’ve decided it’s about time to get some centralized monitoring going. To that end, I’ve gone with what I’m (vaguely) familiar with: the Grafana open source logs display and its accompanying pieces. Here, I’ll lay out approximately how I got working home monitoring set up after a couple missteps.

Part 1 will focus on everything except Prometheus and then we’ll come back to that one in part 2.

Running Sandstorm From a Raid 1 Drive Array

Sat, 22 Feb 2025 11:06:49 -0500

In my quest to back slowly towards the exits from total reliance on Google’s infrastructure, I’ve managed to stand up an instance of Sandstorm on a small ZimaBoard. This has been successful; one thing I was very concerned about was storage reliability because I know if I’m rotating away from someone else’s Cloud, it’s up to me whether I lose data if these drives break. To that end, I put both two Seagate 2TB drives in a CENMATE 2-drive SATA enclosure and went about setting up a RAID-1.

Unstick Terminals in Emacs

Sat, 15 Feb 2025 19:28:27 -0500

I’ve used multi-term for years in emacs as my primary terminal interface. It works great, but occasionally while ssh’ing to another machine and using the emacsclient -t interface (my common approach), the terminal gets stuck to a too-small size. This happens most commonly when my ssh session crashes and I have to start a new one.

It turns out the cause of this is that the terminal is taking its measurements from the other emacs window it’s bound to, and if you unbind it, it’ll be willing to take measurements from a new window.

Fireplace on a Raspberry Pi

Sun, 26 Jan 2025 21:33:07 -0500

After not too much work, I was able to finish up the fireplace in our front room. This was a small hack involving a Raspberry Pi. I’ll summarize what worked and then share a few thoughts on what didn’t.

What worked

Here’s the quick summary:

Formatted a new Raspberry Pi 4B with a fresh OS install.
In the Raspberry Pi settings, set boot to console.
Set up a default fireplace user, install a 5-minute loopable video of a fireplace, and write a tiny script to invoke it. This lives in the /home/fireplace/kiosk/play-fireplace.sh directory.

#!/usr/bin/sh

cvlc -Lf fireplace-5min.mp4

I can test this here and confirm it works.

WebGL Fire Shader Based on Fractal Brownian Motion

Wed, 22 Jan 2025 19:27:32 -0500

This is a followup to my previous post on building a shader based on Xflame. I won’t be covering much of the details of building it since they’ll be similar.

You can see the shader in action here. Feel free to pop it open and inspect the code as we go.

There are two primary pieces worth talking about in this one: the noise source and the Fractal Brownian Motion algorithm. As always, The Book of Shaders does a much better job of deep-diving on these topics than I intend to, so if you start to feel lost, I’ll provide links that you can read up on and come back.

WebGL Fire Shader Based on Xflame

Sat, 18 Jan 2025 10:18:44 -0500

Over the holiday, we had the fun idea to put a TV in front of the fireplace we never turn on so we can run fireplace images on it.

Really ties the room together.

It’s been a joy, but it got me thinking about what it would take to put a fire visualizer on there instead of videos of fireplaces. To that end, I’ve dusted off my old knowledge of GLSL and taken the opportunity to start experimenting with making a fire effect with webgl shaders. This took me down a couple of fun paths!

Recreating the Cortex Theme Journal in Emacs Org Mode

Sun, 29 Dec 2024 17:52:03 -0500

It’s the New Years season again, and that means resolutions. Usually. This time around, I’m trying something a little new. Inspired by CGP Grey’s video on the topic, I’m trying “theme system journaling.” But since I’m not very good at keeping physical journals, I’ve recapitulated the system in emacs using org-mode, yasnippet, and some additional code. Here, I’ll go into detail on what I did and how it’s working so far. I learned some really neat org-mode features I wasn’t aware of; this has been a fun journey!

Positioning Multiple Monitors From the Command Line

Sat, 06 Jul 2024 21:49:12 -0400

On rare occasions, I end up needing to plug a second monitor into my laptop. This is a problem I solved in the past with a GUI, but it turns out there’s also a pretty easy-to-use command-line tool for this purpose: xrandr.

To use, first run it by itself

xrandr

This will list your current monitor configuration, which will look something like this:

Screen 0: minimum 320 x 200, current 5569 x 2520, maximum 16384 x 16384
eDP-1 connected primary 1920x1080+0+1440 (normal left inverted right x axis y axis) 309mm x 174mm
   2560x1440     60.00 +  60.00
   1920x1440     60.00
   1856x1392     60.00
   1792x1344     60.00
   2048x1152     60.00
   1920x1200     60.00
   1920x1080     60.00*
   1600x1200     60.00
. . . etc . . .
HDMI-1 disconnected (normal left inverted right x axis y axis)
DP-2 connected 3440x1440+2129+0 (normal left inverted right x axis y axis) 800mm x 335mm
   3440x1440     59.97*+  29.99
   2560x1440     59.95
   2560x1080     60.00    60.00    59.94
. . . etc . . .

The starred rows are the configurations currently selected for the monitor.

Better Emacs Recipes With Yasnippet and Org-mode

Thu, 11 Apr 2024 21:14:37 -0400

While I’m pretty happy with my recipe system, I recently learned about org-babel, which is now integreated into the core of org-mode. It turns out this does almost exactly what I want; it’s designed to allow embedding and running code snippets inside an org document in multiple languages. With just a few tweaks, I adapted my previous approach to use org-babel.

The major changes are:

Using org-babel source blocks instead of elisp blocks
Tweaking recipe-do to fire the org-babel source blocks
Substituting local variables at the end of the org file with named blocks at the beginning of the file

Using org-babel source blocks

Org-babel introduces “source blocks,” which are blocks of code in various languages that can be executed. They emit their results in a variety of ways, including to a “result block” below the source block. This is more convenient for tracking the results of running a block.

Emacs Recipes With Yasnippet

Sat, 16 Mar 2024 10:51:19 -0400

A common pattern while working on computer projects is running through a sequence of “semi-automatic” operations, where you can’t quite automate all the steps fully, but the formula is basically the same every time. I call these workflows “recipes,” and they have these shared properties:

There’s a set of steps that’s almost always the same (but not always)
Frequently, especially when they’re software development, they take hours / days, long enough for interruptions to happen in the middle

I’m easily distracted, so it’s common for me to lose track of where I am following a recipe and burn some time picking myself back up.

I created a simple flash card viewer

Mon, 15 Jan 2024 15:45:43 -0500

The flash card viewer

I’ve created a simple flash card viewer as a study aid. It currently defaults to flash cards for the FIRST Robotics Competition 2024 game manual, but you can load your own into it by clicking the “Cards” dropdown and pasting text like the following into the box:

Card front 1

Card back 1
-
Card front 2

Card back 2
-
Etc

And so on

Card state is stashed to local storage, so your edits will be preserved.

Challenges for Mastodon

Wed, 25 Oct 2023 21:42:42 -0400

In a previous post, I talked about things I really enjoy about Mastodon. This time around, I’ll go over some challenges I see for the tool as a platform, product, and ecosystem. Before reading too much into these, note that it’s possible not all of these need to be fixed! Some can be interpreted as an improvement over the status quo of Twitter / Reddit / Facebook (especially if you are privacy-conscious). But these are things that will feel strange for people who are used to those other systems. I’ll also try to offer some mitigation suggestions, or at least expound on why I don’t think they can / should be easily mitigated.

Things I Like About Mastodon

Fri, 20 Oct 2023 19:40:23 -0400

I’ve been maintaining my own Mastodon node for a few months now, enough to feel pretty moved-in, all things considered. To nobody’s surprise, I’m really enjoying it!

I’m going to do a back-to-back pair of posts about the pros and cons I’m seeing in the ecosystem right now. Leading off with my favorite things. This is the stuff that completely makes it worth my time to keep building and maintaining this server.

Debugging 502 errors in Mastodon

Sun, 15 Oct 2023 20:25:30 -0400

Recently after making some changes to my Mastodon server, I began suffering a host of 502 and 500 errors. The root cause turned out to be something unexpected, so I thought I’d document my debugging process to explain how I tracked it down. This post will also serve as, I hope, an answer to someone wrestling with their own server if they have the same problem.

Spoiler: if you get a lot of IPAddr::InvalidAddressError in your service logs, make sure you haven’t set the ALLOW_PRIVATE_ADDRESSES environment variable to something invalid like localhost. That’s a comma-separated list of IP addresses; it should be 127.0.0.1 if it’s anything.

Cycling X-Clacks-Overhead output in Mastodon

Sat, 14 Oct 2023 15:32:18 -0400

“We keep that name moving in the Overhead,” he said, and it seemed to Princess that the wind in the shutter arrays above her blew more forlornly, and the everlasting clicking of the shutters grew more urgent. “He’d never have wanted to go home. He was a real linesman. His name is in the code, in the wind, in the rigging, and the shutters. Haven’t you ever heard the saying ‘Man’s not dead while his name is still spoken’?”

Enabling Translations in your Mastodon Node with LibreTranslate

Thu, 12 Oct 2023 20:00:49 -0400

Out-of-the-box, Mastodon supports post translation using an external service. But to take advantage of it, you have to set up the services and bind your Mastodon instance to them.

It turns out this is a relatively simple process with only a few sharp edges. I’ve documented my walk to a working configuration here. This process was supported by the Mastodon documentation and this delightful tutorial for setting up LibreTranslate in Docker.

Showing Note as Suffix on Username

Sat, 07 Oct 2023 11:00:00 -0400

Having put all the pieces in place, we’re now ready to modify the UI to display the attached note next to the user’s name. We’ll have to do a bit of plumbing to account for our own sins (denormalizing the field into the post means we’ll need to re-normalize it into accounts on the client-side). But then it’s just a few short tweaks to the React components to display it.

Setting Up a Dev Environment for Mastodon

Wed, 04 Oct 2023 23:00:00 +0000

This post is part 2 of a 3-part series on adding the ability to show notes about users on Mastodon next to their display names. Here, I talk a bit about setting up a dev environment to make changes to the Mastodon UI.

Parts of this series:

When you modify the Ruby files making up the Mastodon server, those changes immediately impact the running server and no further manual intervention is needed for testing. To complete Part 1, I actually changed and tested on my production server; not best practice, but it worked.

Adding a field to the Mastodon API

Wed, 04 Oct 2023 01:30:00 +0000

When I was younger, I expected everyone in the future would have computer handles we’d mostly go by, and names would be secondary. I gleefully memorized hundreds of online handles for all the folks I knew in school and online.

Also, we’d all dress like this.

It turned out, that didn’t exactly happen. People still keep their (usually) parent-assigned names and use them often.

Backing Up Daily, Weekly, and Monthly with Cron

Fri, 25 Aug 2023 23:32:37 -0400

Now that my Mastodon server is making regular backups, I want to preserve some of the backups on the off chance something goes desparately wrong with my configuration and I have to do a very large rollback.

It turns out, while cron is maybe not the friendliest tool around, it makes this task very easy. What I want to do is a three-tier backup: daily, weekly, monthly. I only plan to keep one instance of each.

Backing Up Mastodon and expanding its storage

Tue, 08 Aug 2023 21:47:50 -0400

My Mastodon server has reached the point where it’s complex enough that backing up would be prudent. I was a litle surprised to discover that a script to do this for me is not provided in the default project. The project does have a comprehensive overview of the steps to backup, so I set about making my own backup script. In the process, I also discovered a need for way more storage, so I’ll talk a bit about how I did that also.

Setting Up Mastodon on a Raspberry Pi 4

Mon, 17 Jul 2023 09:11:54 -0400

I recently set up a Mastodon node on a Raspberry Pi 4 in my home. By and large, the process went smoothly, but I hit a couple of corner cases I wanted to document (both for myself and anyone else following this path in the future).

For the most part, I followed the admin setup guide provided by the Mastodon team. I had to deviate from it in terms of three pieces:

The Art of Computer Programming, I.B.Profin Edition: Chapter 1.1 - Algorithms

Thu, 08 Jun 2023 17:58:26 -0400

About four years and one detour through some self-teaching in control system theory later, I have returned to Donald Knuth’s famous tome, The Art of Computer Programming (volume 1). My previous attempt to read it was extremely discouraging as I stumbled on the first part of the first chapter. Taking a second read through, it made sense this time. When I first got stuck, I went looking for discussion on the topic online and was unable to find it; I’m making this post in the hopes that it’ll help some other reader in the future succeed where I initially failed.

Beating Up React for Fun (and Profit?): Using React to Drive Another Component Tree

Sun, 23 Apr 2023 11:24:18 -0400

React is a clever user interface library designed around a very functional paradigm, where the input is some state (represented as properties) and the output is a tree of renderable user interface components (represented as, usually, something that can be translated to another UI representation, such as an HTML element tree).

That’s all well and good, but what if the render tree is already established, but you want to use React to drive updates to it?

A Python driver module for Brilliant Labs Monocle

Sat, 01 Apr 2023 16:34:11 -0400

I bundled up the things I learned about driving a Brilliant Labs Monocle into a new Python package. While doing the fine-tuning, I learned a bit more about driving the MicroPython UART interface.

Worth noting: I only discovered it after I completed this project, but another good example of using Python to drive Monocle actually comes from the Monocle’s creators.

Fine-tuning the connection

The UART service has a maximum size of data it can consume in one “chunk;” overflowing this limit can result in dropping bytes. As of right now, the count is 128 bytes (- 3 bytes for overhead). For some reason I haven’t sussed out yet, the BLE characteristic reports the size is only 20 bytes, so hard-coding it to 128 sped it up. The Bleak module will do chunking for you if you set the mtu_size, but I implemented my own (mostly because I didn’t know Bleak would handle it for me, but now that it’s implemented I like the logging so I’m keeping it.

Controlling Monocle from a python script

Sat, 25 Mar 2023 08:07:50 -0400

I recently got my hands on a Brilliant Labs Monocle, which is a nifty little tiny-screen device that connects to a host machine via Bluetooth Low-Energy protocol and offers a simple API for controlling its content and receiving input. The documentation is a little thin-on-the-ground on how to interface it to a host, but after a little bit of hacking on it I pieced it together.

VSCode: connecting from Linux to Windows

Sun, 19 Feb 2023 08:00:00 -0500

Recently, while working on the WPILib codebase, I found that my poor Linux laptop was not upgraded enough to do the heavy-lifting, as the codebase has pulled in a dependency on GLIBC 2.32 and I’m unwilling to risk my laptop upgrading from Ubuntu 20 to 22. Rather than give up, I shifted my development work to a Windows PC that I drive from my laptop.

I’ve used the SSH plugin for VSCode in the past and it’s a solution I’m fond of. Setting it up took just a few steps on the host machine and the client machine.

On AI Art

Wed, 28 Dec 2022 11:52:46 -0500

So I’m in Blender and I’m generating asteroids using the Add Mesh -> Rock Generator tool (part of the “Add Mesh: Extra Objects” add-on) with an Asteroid template.

click

Each of these rocks is created using a few overlapped mathematical algorithms. The math is pure math, procedurally understood, with no hidden-node neural network in play.

click

The results are sufficient to serve the purpose of putting a rock in a game or image with maybe a little polish. The whole script is here.

LaTeX Content From Command Line

Mon, 31 Oct 2022 13:11:50 -0400

So I have found myself in the market for a new job recently. This isn’t the best feeling in the world, but I’m not letting an opportunity go to waste. Today, let’s talk about how to create a simple script that injects some content into a LaTex document, in the context of creating a script that emits different résumés with command-line-specified objectives.

Let’s stop retyping this

Playing with AprilTags: Python Recognizer

Mon, 19 Sep 2022 08:00:00 -0400

An announcement by FIRST Robotics earlier this year revealed an interesting bit of news: next year’s kit would include AprilTags as vision targets. I’m completely unfamiliar with these, so I figured it’d be fun to dive in and see what they’re all about.

Generating some tags

AprilTags are a so-called “fiducial” system that identifies not only a position and orientation, but an identifier code as well via a block encoding scheme, conceptually similar to a barcode but with some design features useful to making them easy to comprehend from multiple angles. FRC is planning to use the 36h11, so I grabbed a few samples from the repository. They’re stored in minimized “one pixel per block” format, so to make them tractable I blew them up and bordered them with ImageMagick (convert tag36_11_00001.png -scale 10000% -bordercolor white -border 200 tag36_11_00001-large.png) and ran them out on the printer. I grabbed a few reference numbers to play with: 1, 42, and 422.

Create Custom Shuffleboard Plugin: Make It Play Sounds

Mon, 12 Sep 2022 08:00:00 -0400

Having created a new empty custom plugin in the previous post, we are now ready to change it to make it play sounds when the boolean value it monitors goes from false to true. The plugin is available in this GitHub repo.

Adding some visual feedback

Before we add the sound support, we’re going to add some visual feedback so we can test the widget and assure it’s working. We’ll crib from the Boolean Box built-in widget to display grey squares (but since the main goal is sound, not visual, we won’t add the color customization options). Once that’s in, we’ll make the changes we need to wire up sound.

Creating a custom Shuffleboard plugin

Mon, 05 Sep 2022 08:00:00 -0400

Well, it’s off-season for the FIRST Robotics competition, which is always a good time to try new things. This year, I became more interested in Shuffleboard, which is one of the dashboard programs you can use to visualize telemetry from the robot on an attached laptop. Shuffleboard works by inspeting the shared Network tables that the robot and its control computer keep updated and drawing various user-defined widgets based on the values in the table.

Simulating a flywheel part 2: friction and time-step updates

Sat, 23 Apr 2022 00:11:25 -0400

On a previous post, I discussed creating a simulator for a simple flywheel in the FIRST Robotics WPILib framework in Java. We last discussed the high-level framework and simulating a motor; here, we’ll go into simulating friction and how we put it all together.

Friction is deceptively complicated

On the surface, friction is extremely simple. As is taught in high school physics, it’s the force that resists motion proportional to the normal force of the surface pushing against gravity. Which is to say, it’s just -K<sub>d</sub> * m * g, for g the gravitational constant (acceleration) and m the mass of the object, and K<sub>d</sub> the dynamic friction coefficient. Since the flywheel’s axle is pushed down by gravity on its socket, the friction force becomes a counter-torque opposing spin. So, no problem. We calculate the counter-torque, subtract it from the motor’s forward torque, and update every step. Punch that in and… Oh dear.

Simulating a Flywheel part 1: overview and simulating a motor

Mon, 18 Apr 2022 09:00:00 -0400

Well, the off-season of FIRST Robotics is upon us. A time when young people’s minds turn away from robots and towards other things. Like simulating robots!

To give the team something to play with on the software side, I’m putting together a couple of simulators of robot subsystems to experiment with. The first one is a simple flywheel connected to one motor and encoder.

Interface for the simulator, showing the graph of flywheel RPM over time

Piping Linux Audio to a file

Mon, 14 Mar 2022 00:12:26 -0400

I recently had to pipe some audio from my browser to a file. This may not be the most elegant way, but I found it works.

Using SimpleScreenRecorder

For capturing audio and video, I use SimpleScreenRecoder. It’s a pretty no-frills recording program that is intended for (among other things) streaming content from a machine. While it supports both audio and video, I only care about the audio portion for this project.

Resetting my monitor in Linux

Mon, 14 Mar 2022 00:01:48 -0400

Recently, I had an Ubuntu laptop I use regularly develop a weird quirk: sometimes when I plugged it into USB-C, neither the monitor nor power would connect. I discovered I could fix this by simply running lspci on the laptop, which somehow forced both to come back.

As this made no sense, I dug down a bit more. I can’t say I found an answer, but I did find some more things worth questioning.

Logs From The Server

Sat, 26 Feb 2022 10:11:38 -0500

One of the things I’ve missed, having moved my blog off of Blogger, is the metrics. I don’t use the metrics for much, but there’s a nonzero serotonin hit to knowing that my content is read by someone. It’d be nice to be able to restore at least that piece of the Blogger feature-set.

Fortunately, I have access logs and a log analyzer.

I’ve settled on goaccess for my log analysis; it’s pretty straightforward, takes HTTP access logs as input, and presents the data visually (including on the command line). It’s installable on my local machine via the package manager (sudo apt-get install goaccess), so no problems there.

Self Hosted Hugo Comments: data rendered with partials

Wed, 16 Feb 2022 10:05:27 +0100

In an earlier post, I added self-hosted static comments via shortcodes in Hugo. This approach had some benefits, but I didn’t like how it required modifying every blog page to support comments, even if no comments were present.

Hugo has a system of partials and templates to allow for similar pages to have the same layout. We can take advantage of these to handle comments on every blog page. This will pull the comments out of the main flow of the blog posts; we could move them into the front matter of the pages, but insted I’m going to knock out another con of the previous approach and consolidate all comments into one data file.

Self Hosted Hugo Comments: embedded in page

Tue, 15 Feb 2022 11:39:35 +0100

Having chosen to self-host my Hugo comments as part of the static page content, there are a couple of ways to do it. In this article, I explore embedding them in the page using shortcodes.

The method

Comments in my blog are represented by two shortcodes.

comment.html

The first shortcode collects comment data in a semi-structured way and emits it as HTML. Here’s the whole thing.

/layouts/shortcodes/comment.html

{{- $postid := default (.Get 0) (.Get "id") -}}
{{- $username := default (.Get 1) (.Get "username") -}}
{{- $usericon := default (.Get 2) (.Get "usericon") -}}
{{- $postdate := default (.Get 3) (.Get "date") -}}

<div class="comment">
  <div class="user-info">
    {{ if $usericon }}
      <img src="{{$usericon}}">
    {{ end }}
    {{ $username }} {{ $postdate }}
  </div>
  <div class="comments-menu"><a href="mailto:blog+personal-comment@fixermark.com?body=Your Name:%0d%0aIcon:%0d%0aComment:&subject=Comment on {{ $.Page.Permalink }}?comment-id={{ $postid }}">Reply</a></div>
  <div class="comment-body">
    {{ .Inner }}
  </div>
</div>

This code is triggered as, for example,

I'm switching my personal blog to Hugo

Tue, 15 Feb 2022 10:57:53 +0100

After putting a bit of thought into it, I’ve decided to start the process of switching my personal blog to self-hosting on Hugo instead of hosting through Blogger. This blog is staying where it is, but I’ve been playing with the Hugo framework for awhile and am finding I really enjoy it. Expect to see some posts about my experiences with it in here from time-to-time.

Why switch?

Even with the benefit of Google Takeout, moving blog infrastructure is time-consuming. So why have I bothered? A few reasons, in no particular order:

Privacy Policy

Sat, 12 Feb 2022 09:06:28 +0100

Privacy Policy

last updated: 2025-08-02

Change history

2025-08-02: Updated Comments policy to reflect new comment engine

Overview

General Principles

Balancing personal privacy with operational needs

This policy attempts to find middle ground between the needs of the site owner and your needs as a user. I also attempt to adhere to the spirit of the GDPR, but it is a best-effort attempt. In particular, this site will not ask you if you consent to cookies because it does not use cookies.

Mon, 01 Jan 0001 00:00:00 +0000

How to comment

To comment on this blog, send an email to blog+comment@fixermark.com in the following format:

Subject: “Comment on URL of page or ID of comment to reply to”
Body:
- The name by which you’d like to be known
- An icon (image or Gravatar icon URL); 128x128 pixels
- The text of the comment. Markdown formatting will be copied verbatim (unless it interferes with site behavior). Other formats will be matched best-effort.

Comments are updated by hand periodically. To remove a comment, see the privacy policy.