blog: doomswiping

.gitattributes

@@ -0,0 +1 @@
+*.png filter=lfs diff=lfs merge=lfs -text

blogs/2022/10/17/drone-ci.md

@@ -0,0 +1,121 @@
+# Drone CI
+
+When it comes to automation, [GitLab CI](https://gitlab.com) has been my go-to for running builds, tests and deployments of projects from static websites to 3D open-world games.
+This has generally been on a self-hosted installation, and often makes use of physical runners.
+However, I have some gripes: I mostly only use it for the CI, but it comes with an issue tracker and Git hosting solution too - great for some cases, but overkill in so many others.
+Because it's such a complete solution, GitLab is a bit of a resource hog, and can often run frustratingly slowly.
+
+Recently I've been playing with a friend's self-hosted instance of [Drone CI](https://drone.io/) as a lightweight alternative, and I much prefer it.
+I didn't set up the instance, so that part is out of scope for this post, but in case it's relevant, we're using a self-hosted [Gitea](https://gitea.io/) instance to host the source.
+You can find out about configuring Drone with Gitea [here](https://docs.drone.io/server/provider/gitea/).
+
+
+## Yet Another Yaml Config
+
+Like GitLab, Drone is configured via a YAML file at the project root, called `.drone.yml`.
+Drone is configured by creating 'steps' to the pipeline, where GitLab uses 'jobs'.
+
+My first project's automation requirements were small - all I needed for a deployment was to copy all the files in a directory on every push to the `main` branch.
+This means I needed secure access to the host, and the ability to copy files to it.
+I didn't want to dedicate any permanent resources to such a small project, so opted for the `docker` pipeline option.
+
+My pipeline would contain a single `deploy` step which would configure SSH access to the host, and then use it to copy the relevant files from the checked out version of the project.
+I decided to use `ubuntu` as the Docker image for familiarity and accessibility - there are probably better options.
+Drone widely supports Docker image registries; I have not used Docker much, but would like to get more experience with it.
+
+```yml
+kind: pipeline
+type: docker
+name: deploy
+
+steps:
+- name: deploy
+  image: ubuntu
+  when:
+    branch:
+    - main
+
+  commands:
+    - echo hello world
+```
+
+## Secrets
+
+A hugely important aspect of automation is ensuring the security of one's pipelines.
+Automated access between pipelines is a big risk, and should be locked down as much as possible.
+For passing around secrets such as passwords and SSH keys, Drone has a concept of secrets.
+I created a private key on my local machine for the runner's access to the remote host, and added a [per-repository secret](https://docs.drone.io/secret/repository/) to contain the value.
+This is a named string value which can be accessed from within the context of a single pipeline step.
+
+I also created secrets to contain values for the remote host address and the user to login as.
+These are less of a security concern than the private SSH key, but we should obfuscate them anyway.
+It's also a useful step towards generalising the pipeline for other projects: I can use the same set of commands in multiple CI configurations, and just update the secrets from the project page.
+
+This block was placed in the same step definition as above, below the `image:` entry:
+
+```
+environment:
+  HOST:
+    from_secret: host
+  USER:
+    from_secret: user
+  SSH_KEY:
+    from_secret: ssh_key
+```
+
+## Connecting
+
+To use the SSH key, we need to spin up `ssh-agent` and load our key into it.
+Since it's passed into the job as an environment variable, this involves first writing it to a file.
+We also need to disable host key checking (the bit that asks if you're sure you want to connect to a new host) as we're making an automated SSH connection, and therefore won't be there to type 'yes'.
+
+```yml
+# configure ssh
+- eval $(ssh-agent -s)
+- mkdir -p ~/.ssh
+- echo "$SSH_KEY" > ~/.ssh/id_rsa
+- chmod 600 ~/.ssh/id_rsa
+- ssh-add
+- echo "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
+```
+
+Finally, it's time to run some SSH commands.
+I had a bit of trouble getting the hang of variable templating here - it took some trial and error to figure out what variables would get expanded and when.
+Since my `HOST` and `USER` values are defined in secrets, I had to get them from my evironment variables and into a correctly formatted string for the SSH target.
+As I would be running multiple commands, I also wanted to store this in a variable to keep the SSH commands short in the Drone config.
+
+What ended up working for me was this:
+
+```yml
+# environment variables get expanded (twice?)
+- host="$${USER}@$${HOST}"
+# running 'hostname' on the deploy target
+- ssh $host "hostname"
+```
+
+## Images
+
+It's pretty cool to be able to pass a repository through several Docker images through the pipeline.
+I have my website's Makefile set up to build off my local machine, which is on Arch.
+It therefore depends on Arch-specific package names.
+I didn't want to have to hack around my existing build configuration just to build it automatically, but I also found that the deploy steps I'd already written worked best on Ubuntu.
+
+For Drone, this is no problem - I can simply specify `image: archlinux` in the build stage, and `image: ubuntu` for the deploy step.
+My Makefile and local workflow requires no changes at all, but I can still use the more robust deploy steps from Ubuntu.
+
+## Final thoughts
+
+I like Drone's minimalist approach to CI.
+There isn't much in terms of configuration, and the interface is much snappier than Gitlab's.
+It will take a bit more work to get a full workflow - Gitlab basically has one out the box - but working with more separate components should provide flexibility and resilience in the long run.
+
+I'd like to explore some more features, like [templates](https://docs.drone.io/template/yaml/) for steps shared between repositories, and spend more time tuning exactly when pipelines run.
+I also want to try building some more complex projects, such as those using game engines like Godot, and those targeting multiple target platforms.
+Those are adventures for another day, though.
+
+That's all for now, thanks for reading and see you next time!
+
+## References
+
+* [GitLab CI config to deploy via SSH](https://medium.com/@hfally/a-gitlab-ci-config-to-deploy-to-your-server-via-ssh-43bf3cf93775)
+

blogs/2022/10/18/the-prince-of-milk.md

@@ -0,0 +1,30 @@
+# The Prince of Milk
+
+The Prince of Milk is a science fiction novel by Exurb1a of YouTube fame.
+
+It follows the story of a fictional village in southern England named Wilthail, which ends up the unwilling venue for the settling of an ancient grudge.
+Deities ("Etherics") exist alongside the mundanity of 21st century Wilthail, and engage in absurdity, sodomy and violence with its quaint population.
+The books makes reference to a number of popular philosophical debates, and takes inspiration from a number of classical sci-fi authors.
+
+A common theme is the idea that power is relative.
+The Etherics are immortal - their grudge has played out across hundreds of 'Corporic' incarnations - and have power and abilities far beyond the comprehension of their human counterparts.
+However, they do not necessarily view themselves as gods.
+This is particularly true of the character Beomus, who frequently plays down their immortality and returns fire with questions about modern humans' relationship to their primitive ancestors, or with ants.
+This relativity of power recurs plenty, and is reminiscient of Arthur C. Clarke's assertion that sufficiently advanced technology is indistinguishable from magic.
+As characters in a book, the Etherics are understandably cagey about how any of their abilities work - but broadly refuse to classify them as either magic or technology.
+
+Reincarnation is viewed as a fundamental way of the world - Chalmers' panpsychism, or the Hard Problem of Philosophy.
+This goes further than to suggest that people are simply reincarnated as others when they die, rather suggesting that consciousness is a fundamental force of the universe, in just the way electromagnetism is.
+It's a recursive thing, from the lowliest atom up through rocks, mice, snakes, cats, people, stars and gods.
+It's a neat and satisfying view, and one that has yet to be disproven by neuroscience.
+
+The human characters are invariably damaged - mental health issues, broken relationships, toxic parentage, drug use, suicide, difficult histories.
+This paints PoM's world as realistic, and grounds it through the fantastical happenings in the middle act.
+It grips the reader with its variety of characters, and follows them all as they confront not only their own personal hells, but the one they now find themselves sharing, in a twisted take on country bumpkinism.
+
+Overall, I thoroughly enjoyed this book, and am looking forward to reading more of Exurb1a's writing.
+I am a little biased, as I have already enjoyed the YouTube channel for a number of years.
+
+There is a short glossary at the end naming and exploring some of the particular concepts explored in the novel, which prompt the reader to explore further.
+Top marks!
+

blogs/2022/11/13/un-cafe-dans-lespace.md

@@ -0,0 +1,11 @@
+# Un Cafe Dans l'Espace
+
+J'ai acheté ce livre quand j'ai visité la Cité de l'Espace à Toulouse. C'est écrit par Michel Tognini, un astronaute français qui été dans l'espace deux fois. Il a travillé sur la station spatiale de Mir, et sur la navette spatiale pour décoller CHANDRA, une observatoir dans le bas orbite. Depuis, il a selectionné et entrainé de nouveaux astronautes européens.
+
+Ce livre parle de plusiers subjets en relation à l'espace: de l'entrainement de l'auteur à la Cité des Étoiles en Russie, de les échecs et défis dans l'espace, aux réalisations des sociétés privés comme SpaceX, Blue Origin et Virgin Galactic. Comme d'autres astronautes, Tognini a étudié comme pilote de chasse, et puis comme pilote d'essai. Il a rejoint l'agence spatiale française CNES avant la formation de l'ESA, qui existe encore aujourd'hui. 
+
+J'ai trouvé que je connaissais déjà beaucoup des histoires dans ce livre, parce que j'ai toujours eu une adoration pour l'espace, et c'est écrit pour une audience générale. Ma première raison de lire ce livre est que c'était mon premier français! Cela m'a pris quelques mois, mais c'etait une experience agréable. Au début, j'avais besoin de rechercer plusiers mots à chaque page, mais à la fin j'ai trouvé que je pouvais lire beaucoup d'aisance.
+
+Je recommende ce livre aux francophones qui sont interessés par l'espace, mais qui sont peut-être moins familiers avec le jargon comme moi.
+
+Encore, merci à mon cher Ethel pour m'aider avec mon français ! <3

blogs/2022/12/03/automount-nfs.md

@@ -0,0 +1,96 @@
+# Automounting network drives with NFS
+
+This is the first part of a series of posts about setting up a music server using a NAS and Raspberry Pi. The next part is [here](https://ktyl.dev/blog/2022/12/19/pi-mpd-music-server.md).
+
+---
+
+I have a NAS which supports NFS, which I use to store all of my photos, music and other media on my local network.
+This gives me OS-independent to all of these files, and frees up drive space on my laptops and desktop - most of which are dual-booted.
+On Windows it's fairly straightforward to establish a network drive, but on Linux-based systems - at least on the Debian- and Arch- based distros I find myself using - the process is a little more involved.
+
+Here I'll use `systemd` to automatically mount a shared folder when they're accessed by a client machine.
+There are other ways to do this, but as my machines predimonantly run Debian- or Arch-derived Linux distributions, `systemd` is a choice that works for both.
+This post is largely based on the description on the [ArchWiki](https://wiki.archlinux.org/title/NFS#As_systemd_unit).
+My NAS' hostname is `sleeper-service`, and I'll be mounting the `Music` shared folder.
+
+You'll need the appropriate package to mount NFS filesytems.
+On Arch Linux, `nfs-utils` is what you'll be after.
+On Debian, the client pckage is `nfs-common`, which may already be installed.
+You may also need to configure security on your NAS to allow NFS connections from your local machine's IP.
+
+## Initial mount
+
+Before doing anything automatically, we first need to create a `systemd` unit to mount the remote filesystem at a path in our local filesystem.
+I'll mount the remote folder onto the local path `/sleeper-service/Music`.
+When creating this file, pay attention to its name, as it's important for it to correspond to the path of the mountpoint.
+The correct name can be determined using `systemd-escape` - pay attention to escape characters in the output, this caught me out several times.
+
+```
+$ systemd-escape /sleeper-service/Music
+-sleeper\x2dservice-Music
+$ sudo touch /etc/systemd/system/sleeper\\x2dservice-Music.mount
+```
+
+Don't ask me why `systemd` is like this - I think it's silly too.
+After creating the unit file, we then need to edit it and fill out some information, specifying where the remote filesystem is and also when we need to initialise it.
+
+Here I used a name instead of an address for the `What=` part - I have an entry for `sleeper-service` configured in `/etc/hosts`, but you can equally use an IP address just as well.
+
+```
+[Unit]
+Description=Mount music at boot
+
+[Mount]
+What=sleeper-service:/volume1/Music
+Where=/sleeper-service/Music
+Options=vers=3
+Type=nfs
+TimeoutSec=30
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Once we've created this, we can try to manually mount the shared folder by starting the unit:
+
+```
+$ sudo systemctl start sleeper\\x2dservice-Music.mount
+$ ls /sleeper-service/Music
+```
+
+At this stage you ought to see the contents of your shared folder.
+Next, we want to set up the automount, so that this remote folder is mounted automatically when we try to access it.
+To do that, we need to first stop/disable the unit we just created:
+
+```
+$ sudo systemctl disable sleeper\\x2dservice-Music.mount
+```
+
+Then, let's create an `.automount` unit with the same name as the `.mount` file we already have.
+The automount unit expects the mount unit to exist alongside it - it doesn't replace it.
+
+```
+$ sudo touch /etc/systemd/system/sleeper\\x2dservice-Music.automount
+```
+
+```
+[Unit]
+Description=Automount NAS music
+
+[Automount]
+Where=/sleeper-service/Music
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Then, enable the new `.automount` unit to have it run automatically:
+
+```
+$ sudo systemctl enable sleeper\\x2dservice-Music.automount
+```
+
+The folder should now be automatically mounted at the target location when trying to access it.
+
+As always, thanks for reading and I hope this was helpful.
+If I got something wrong, or there's an easier way to do it, or you just want to say hi, please don't hesitate to [get in touch!](mailto:me@ktyl.dev)

blogs/2022/12/15/stable-diffusion.md

@@ -0,0 +1,128 @@
+# Local Stable Diffusion
+
+![astronaut rides horse](astronaut_rides_horse.jpg)
+
+Stable diffusion (SD) is an AI technique for generating images from text prompts.
+Similar to DALL-E, which drives the popular [craiyon](https://www.craiyon.com/), SD is available as an [online tool](https://huggingface.co/spaces/stabilityai/stable-diffusion).
+These web tools are amazing, and easy to use, but can be frustrating - they're often under high load, and impose long waiting times.
+They use a good chunk of computational resources, specifically GPUs and so have generally been out of reach for even people with powerful personal machines.
+
+Now, however, SD has reached the point it can be run using (admittedly, high-end) consumer video cards.
+Stability AI - the model's developers - recently [published a blog post](https://stability.ai/blog/stable-diffusion-v2-release) open-sourcing SD 2.
+There's a README for getting started [here](https://huggingface.co/stabilityai/stable-diffusion-2/blob/main/README.md), but it has a couple of gotchas and assumptions which plenty of people (like myself) won't have known if they're not already familiar with the technologies in use, such as Python and CUDA.
+
+This post is descibes my experience setting up SD 2 on my local workstation.
+For hardware, I have an i7-6700k, RTX 2080 Super and 48GB of RAM.
+If you have an AMD video card, you won't be able to use CUDA, but you may be able to use GPU acceleration regardless using something ROCm.
+In this post I'm using Arch Linux, but I have successfully set it up on Windows too.
+Python is an exceedingly portable language, so it should work wherever you're able to get a Python installation.
+
+This post assumes that you already have a working Python installation.
+
+## Install CUDA
+
+CUDA needs to be installed separately from Python dependencies.
+It is quite large, and as with all NVIDIA driver installations, can be a bit confusing.
+On Linux, it's straightforward to install it from your distribution's package manager.
+
+```bash
+sudo pacman -Syu
+sudo pacman -S cuda
+```
+
+On Windows, you will need to go to NVIDIA's site to download the correct version of CUDA.
+At time of writing, the SD 2 script expects CUDA 11.7, and will not work if you install the latest 12.0 version.
+To get older versions, go to their [download archive](https://developer.nvidia.com/cuda-toolkit-archive) and select the appropriate one.
+
+## Set up a virtual environment and PyTorch
+
+Python can be installed at a system level, but it's usually a good idea to set up a virtual environment for your project.
+This isolates the project dependencies from the wider system, and makes your setup reproducible.
+I will use [`pipenv`](https://pipenv.pypa.io/en/latest/index.html) as it's what I'm familiar with.
+
+PyTorch is a deep-learning framework, used to put together machine learning pipelines.
+
+To get a command to install the relevant dependencies, go to [PyTorch's site](https://pytorch.org/get-started/locally/) and choose the options for your setup.
+In my case, I replaced `pip3` with `pipenv` as I want to install dependencies to a new virtual environment instead of to the system.
+
+```bash
+mkdir stable-diffusion && cd stable-diffusion
+pipenv install torch torchvision torchaudio
+```
+
+## Install Stable Diffusion
+
+SD 2 is provided by the `diffusers` package.
+We can install it in our virtual environment as follows:
+
+```bash
+pipenv shell
+pip3 install git+https://github.com/huggingface/diffusers.git transformers accelerate scipy
+exit
+```
+
+We use `pipenv shell` to enter a shell using the virtual environment, before using the `pip3` command described on their README.
+After installing dependencies, we can leave the virtual environment shell and return to our original one.
+`transformers` and `accelerate` are optional, but used to reduce memory usage and so are recommended.
+
+## Create a Python script
+
+Python does have an interactive envronment, but so save our fingers let's use a `stable-diffusion.py` script to contain and run our Python code.
+Here I'll mostly copy the Python included in their README:
+
+```python
+import torch
+from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler
+
+model_id = "stabilityai/stable-diffusion-2"
+
+# Use the Euler scheduler here instead
+scheduler = EulerDiscreteScheduler.from_pretrained(model_id, subfolder="scheduler")
+pipe = StableDiffusionPipeline.from_pretrained(model_id, scheduler=scheduler, revision="fp16", torch_dtype=torch.float16)
+pipe = pipe.to("cuda")
+pipe.enable_attention_slicing()
+
+prompt = "a photo of an astronaut riding a horse on mars"
+image = pipe(prompt, height=768, width=768).images[0]
+    
+image.save("astronaut_rides_horse.png")
+```
+
+I've made two additions here.
+First, I've added `import torch` at the top - I'm not sure why the code in the README omits this, but it's needed to work.
+
+I've also added `pipe.enable_attention_slicing()` - this is a more memory-efficient running mode, which is less intensive at the cost of taking longer.
+If you have a monster video card, this may not be necessary.
+
+At this point, we're done - after running the script successfully, you should have a new picture of an astronaut riding a horse on mars.
+
+## Some nice-to-haves
+
+In this basic script we only have the one, hardcoded prompt.
+To change it, we need to update the file itself.
+Instead, we can change how `prompt` is set, and have it read from command-line parameters instead.
+
+```python
+# at the top of the file
+import sys
+
+...
+
+prompt = " ".join(sys.argv[1:])
+```
+
+While we're at it, we can also base the filename on the input prompt:
+
+```python
+image.save(f'{prompt.replace(" ", "_")}.png')
+```
+
+## Wrapping up
+
+And that's it!
+Enjoy making some generative art.
+My favourites so far have been prefixing "psychedelic" to things.
+I've also been enjoying generating descriptions with [ChatGPT](https://chat.openai.com/chat) and plugging them into SD, for some zero-effort creativity.
+As always, if anything's out of place of if you'd like to get in touch, please [send me an email!](mailto:me@ktyl.dev).
+
+

blogs/2022/12/17/gpt-game-dialogue.md

@@ -0,0 +1,58 @@
+# Game dialogue with ChatGPT
+
+[ChatGPT](https://chat.openai.com/chat) has become the latest AI application to enjoy viral popularity.
+At time of writing it's a closed-source research tool developed by OpenAI, with the only access being via their web portal.
+Users have to create an account to interact with the bot, and have no API access, though they no doubt have one internally.
+I think given its capabilities, this is probably a good idea for now, but I'd like to outline the impact it can already have in game development, even in its fairly limited form.
+
+However, it can already be made immensely useful for content generation, without any kind of API access.
+Generally, characters come in two flavours: main characters, whose motivations and actions shape the story; and generic NPCs, who exist to fill out the world for the player.
+
+For the story to carry the author's intent (which they might not necessarily care about), it would probably be best not to leave ChatGPT to generate a plotline on its own.
+Its susceptibilty to bias is a problem - try generating men or women and count how often they're describing as petite, as having chiseled jaws or as wearing form-fitting dresses.
+It can be coaxed out of this with enough description, but lots of manual intervention defeats any content generation technique.
+
+The other group of characters, though, I think represents ripe pickings.
+Often in a game world, background dialogue quickly becomes stale, as lines are reused.
+ChatGPT can already easily be used as a supporting writer to generate a huge amount of less-than-critical dialogue.
+Take, for example, a merchant.
+
+![generating merchant dialogue](merchant_prompt.png)
+
+This psuedo-format is instantly combatible with a simple templating system.
+It would be trivial to generate variations using perfectly traditional programming techniques.
+This prompt took a minute to write, and includes specific about the character's context, as well as a slightly more than default personality.
+
+We've instantly generated 8 perfectly workable dialogue options for our character, from some basic and mostly templated information about their context.
+However, we notice that our item choices weren't included in the output, though we described them.
+So we ask:
+
+![merchant items](merchant_items.png)
+
+And, instantly, another 8 lines.
+We now have, after a modicum of input, 16 possible lines for a background merchant character to respond with when interacted with.
+With some templated prompt generation, this could be made even faster than the description given here.
+
+It's also capable of going beyond just lines dialogue.
+[Ibralogue](https://github.com/Ibralogue/Ibralogue)'s developer taught it the syntax, had it generate an example and then taught it a new feature:
+
+![sprite prompt](sprite_prompt.png)
+
+![sprite response](sprite_response.png)
+
+All that's left is to copy the output and paste it into a text file for a game to use.
+
+---
+
+This is barely even a scratch on what ChatGPT or systems like it are already capable of.
+At present, the website gets overloaded, you can't save and reload conversations, and its content filtering is very much evolving problem. 
+However, even with those limitations it's an extraordinarily powerful tool, and this is just one very minor example of an application.
+
+That's it from me, but I'd love to read more discussion about use cases and the ethical issues at play.
+If you have anything interesting, please [get in touch](mailto:me@ktyl.dev)!
+
+
+
+
+
+

blogs/2022/12/19/pi-mpd-music-server.md

@@ -0,0 +1,126 @@
+# NAS-based music with a Raspberry Pi
+
+This follows on from my [previous post](https://ktyl.dev/blog/2022/12/03/automount-nfs.html) about setting up NFS.
+
+---
+
+I have a large digitised collection of music, and have been experimenting with ways to set up a communal music player in my living room without defaulting to Spotify, or any other such streaming platform.
+Thus far I have used an old laptop with as much music as it will fit loaded onto it, running [MPD](https://www.musicpd.org/) and plugged into some speakers.
+Then, on the laptop (or usually, another, closer laptop) I can connect to the MPD instance with [ncmpcpp](https://github.com/ncmpcpp/ncmpcpp) to change tunes.
+This is an OK solution, but has a few drawbacks: I'm limited to the disk of the laptop, the laptop uses more power than it needs to, and I kind of want that laptop back!
+
+I had the luck to grab a Raspberry Pi from a pop-up store a few weeks ago, and felt that would make a perfect, low-power, unintrusive box to attach to the speakers.
+Ostensibly, the Pi is overkill for just playing music, but it's better than a whole laptop and I'm sure I'll find other jobs for it to do as time goes on.
+
+As for requirements, I have a desktop machine from which I often work from home, and would like my music collection available there too.
+I also often use my laptop in the living room or kitchen, which is also in earshot of the speakers, and I'd like to be able to control the music from my laptop with ease - no cables.
+
+Ideally, these should be stored in the same place, to save having to manage duplicate files and manually synchronising locations, since I am likely to add to my collection from a variety of locations.
+I have spent enough time `rsync`ing albums between machines, life is too short even on a gigabit local network.
+
+I've recently had the good fortune to acquire a Synology NAS, so I'm going to use that to host my music collection.
+However, it's more than possible to jerry-rig a NAS using anything with a hard-drive - maybe even a second Pi.
+Nothing I'm doing should be specific to Synology's hardware or software, as we'll be using [NFS](https://wiki.archlinux.org/title/NFS) to mount remote drives - but exposing an NFS shared folder to the network is therefore out of scope for this post.
+
+## Set up a shared folder
+
+The first step is to centralise my music storage.
+To do this, I created a shared folder from my NAS' web interface, and exposed it to the network.
+
+In my case, I had to specifically add permission for other devices to access the folder via NFS - such as the Pi, my desktop and my laptop.
+It was therefore prudent to assign each of these machines a static IP on my network, so that the NAS can continue to recognise them.
+I also had to set it to map all users to admin, but this is almost certainly a misconfiguration on my part - don't follow me for security advice, I am just tinkering!
+
+My previous blog post goes into detail regarding setting up the NFS configuration.
+
+## Setting up the Pi
+
+My Pi is a Pi 4 Model B, with 4GB of RAM.
+This is more than enough for my needs, and you should be able to get by with much less.
+I went through the initial default setup, noticing that it's much, much slicker than it was on my gen 1 Pi, which ultimately landed me on a graphical desktop.
+
+First, I set a hostname and enabled SSH access, since this is to be a headless machine.
+For the same reason, I disabled the auto-launch of the graphical user interface.
+I would have thought that if it's booted headless, it shouldn't think to launch a graphical session in the first place, but better safe than sorry.
+The point of the thing is to sip power!
+
+## MPD
+
+Next, I installed MPD.
+By default, MPD sets itself up with a `systemd` unit, so it connects as soon as I run `ncmpcpp` from the Pi itself.
+After a reboot, this still seems to be the case, so I'm happy with the default installation.
+
+I pointed it to the automounted music directory by editing `/etc/mpd.conf` and added it to the `audio` group:
+
+```
+music_directory     "/sleeper-service/Music"
+
+group               "audio"
+```
+
+Configured an output for ALSA (I was not able to make it work with Pulse):
+
+```
+audio_output {
+    type        "alsa"
+    name        "My ALSA Device"
+    mixer_type  "software"
+}
+```
+
+We also have to add the `mpd` user to the `audio` group to allow it to access sound devices:
+
+```
+sudo usermod -G audio -a mpd
+```
+
+And enable the driver on boot for the 3.5mm audio jack in  `/etc/modules`:
+
+```
+sudo echo "snd-bcm2835" >> /etc/modules
+```
+
+I found I had errors with MPD failing to create a pid file, so I gave the `mpd` user ownership of the directory it was trying to create it in:
+
+```
+sudo chown -R mpd /run/mpd/
+```
+
+This was a bit of a weird one, since it didn't have this error to start with.
+Nonetheless, after all of that, it works!
+I'm able to play music by running `ncmpcpp` on the Pi itself.
+
+## Remote access
+
+The last thing to configure is access from remote machines.
+I only intend to access it from the local network, so this is pretty straightforward.
+First, to expose MPD to the network, I set its address and port in `/etc/mpd.conf`:
+
+```
+bind_to_address "192.168.1.17"
+port            "6600"
+```
+
+Then, I need only specify the location of the Pi on the network in a local machine's `ncmpcpp` config:
+
+```
+mpd_host = "pifi"
+mpd_port = "6600"
+```
+
+Of course, `pifi` is an entry in my remote machine's `/etc/hosts`.
+
+It's possible you have multiple MPD installations - one on your remote machine, such as a laptop, as well as an installation like the Pi.
+In that case, recall that `ncmpcpp` can be launched with different configs using the `-c` flag:
+
+```
+alias bops="ncmpcpp -c ~/.config/ncmpcpp/config.alt
+```
+
+## Wrapping up
+
+That's all for now.
+At some point in the future I'll write another post on making this setup more accessible.
+I certainly like `ncmpcpp`, but it often garners a scoff from houseguests.
+So, I'd like to pursue the ultimate goal of making it as straightforward to use as something like Spotify.
+As always, I hope this was helpful and please don't hesitate to [get in touch](mailto:me@ktyl.dev)!

blogs/2023/01/08/how-not-to-be-wrong.md

@@ -0,0 +1,13 @@
+# How Not To Be Wrong: The Hidden Maths of Everyday Life
+
+_How Not To Be Wrong_ by Jordan Ellenberg explores mathematical concepts and ideas which permeate our everyday life.
+
+A broad look at mathematical principles which govern some parts of everyday life, and some parts of the not-so-everyday life.
+Generally well-written and approachable, as someone with a maths-adjacent background, there were some parts that I was familiar with, and others less so.
+The author has a sense of humour, and writes well about topics he clearly understands deeply, mostly without boring the reader.
+
+I particularly enjoyed the first few chapters, where a difference is established between the "default" view of mathematics as purely a numbers game about finding exact answers to questions, versus the author's view that it's about finding the questions to ask in the first place.
+Such questions include those such as "how Swedish is too Swedish?", "does lung cancer cause smoking?" and "can slime mold predict elections?".
+
+The book reminded me a bit of Chaos: Making a New Science which I read at the beginning of 2022, though less dry, and pitched to a more general audience.
+I enjoyed some specific parts of the book a lot - particularly those involving geometry and calculus - though could have done without the extensive pieces on statistics, which was always my least favourite sub-discipline at school.

blogs/2023/8/10/doomswiping.md

@@ -0,0 +1,126 @@
+# Doomswiping
+
+## I will profiter
+
+One of the words that's stuck out to me learning French is the verb _profiter_, or _to profit_.
+The direct translation is easy - English and French have substantial shared lineage, and this is a word that's unchanged between the two.
+The usage and connotation of the word between the two languages does differ, however, and I'd like to explore the many senses of the word(s) for spell.
+
+In English, 'to profit' is more often than not associated with financial or economic contexts.
+If one profits from something, they've made money from it, they've got out more than they put in, they've made a worthwhile exchange.
+It is generally used in discussions of wealth, ventures, or commercially applied in business.
+
+In French, _profiter_ means the same thing, but has a much weaker financial connotation.
+Rather, it is associated with personal gain in terms of character growth, positive experiences, improved well-being.
+For example, « *profite bien de tes vacances* » directly translates to "profit well of your holidays", but the meaning is closer to "enjoy your holidays".
+
+In English, we are unlikely to talk of profiting from a holiday, or of a positive personal experience, although it makes perfect grammatical sense.
+We'd understand someone's use of the word in this sense, though we'd think it an odd turn of phrase.
+I think there is something of a knife-edge here, an unstable equilibrium where the same concept resolves to fundamentally different meanings depending on one's own native culture and experience.
+
+---
+
+A well-worn idiom in English is that time is money.
+This makes perfect sense in a commercial setting: our economonic systems prize cost-efficiency and reward those that make the most with the least.
+This is also true in biology; natural selection optimises and specialises organisms to be the best in their niche, and everything else is made extinct.
+In the case of the individual, we could apply the same calculus: our lives each have a finite budget of time available, so it follows that we should optimise how to spend it in order to gain the most utility, whatever that may mean for us each individually.
+
+This is the value proposition put forward by industries like match-making (Hinge), ready-made food delivery (HelloFresh), or educational course providers (Udemy).
+Generally, they provide a means by which to do something one could already do, but with a much reduced time investment.
+There's evidently demand for these industries, and undoubtedly they provide a service that's valued by some segment of the population, so I won't tilt against windmills decrying their existence here.
+However, I think there's cause for concern with such time-optimisation.
+
+Take strategies for meeting people to date, for example.
+If I use a match-making service, I indicate preference towards some individuals, while they do the same to me and others, and some algorithm tries to match us up with people it thinks we'll like.
+If a match is made, we talk, and can arrange to meet up, and from there, perhaps on to form whatever kind of relationship it is we are looking for.
+This is straightforward and convenient.
+
+If instead I rely on meeting people by chance, I have to regularly encounter situations in which I am likely to meet people.
+I have to additionally hope that those people will be the kinds of people I am likely to get along with, and that they are also looking to meet new people.
+I also have to be someone that is interesting enough in a chance encounter that someone I meet would like to see me again.
+This is deeply complex, massively daunting, and extremely time-consuming.
+
+It would seem therefore that dating apps are a much better time investment.
+Instead of having to figure out things to do or places to go, presumably spend money to enable the ordeal, I can instead look for a date while in the midst of the rest of my daily life.
+I know that the people I see there are interested, broadly speaking, in the same thing as me, and can precisely tune my preferences.
+It should work out that not only do I spend less time looking for someone, I also find someone that is likely to closely match myself.
+Therefore, using a dating application is a much better use of my time!
+
+Or is it?
+
+I think there's a flaw here in how we've valued our time.
+Time we've put into our app is time spent we've spent directly pursuing a goal: "I want to find a relationship".
+We've done this efficiently, as the application should optimise our time spent by matching us directly with people, and we're free to spend as much or as little time as we would like.
+But there are several problems with this thinking: we're trusting the application's ability to find something we value; we're assuming our goal can be directly approached; and we're valuing our time in relation to having achieved this goal.
+We'll examine the application first.
+
+## Profiles aren't people
+
+First, it should be re-iterated that when you're using a dating app, you are not looking at people.
+You are looking at people's *profiles*, which I would argue are actually very poor indications of what the people behind them are like.
+It's well-documented that people don't represent themselves honestly on online platforms, and it would be unreasonable to expect them to.
+
+A profile also acts as a filter designed by whatever particular platform you happen to be using, restricting someone to share themselves in a specific format, which further limits any genuine self-expression someone can display.
+This will probably act to negate some of the platform's matching ability.
+
+We also should consider our own biases; applications will allow you to set an age range, political preferences, drink and drug tolerance, religious view, et cetera.
+In plenty of cases this is perfectly reasonable, but isn't it also easy to see how this enables a user to set their own expectations unreasonably high?
+This too, will reduce the algorithm's ability to match effectively.
+
+Humans did not evolve for a digital existence, and relationships are comprehensively _not_ digital.
+We evolved to have rich and complex social interactions, as our survival on the savannah depended on it.
+We track each others' posture, tone, facial expressions, and keep tabs on the interactions between others that aren't ourselves, almost entirely automatically.
+
+None of these values can be meaningfully put into a dating profile.
+Even though they're perfectly available from the first date onwards, at that point you've committed your time and energy to something with a pretty low chance of working out - exactly what you wanted to avoid in the first place!
+
+We also run the risk of cognitive exhaustion.
+Thought profiles aren't people, the parts of our brains that deal with faces don't know that, and will still be running full-tilt as we swipe onwards.
+This processing itself takes energy, and is the social equivalent of junk food, because there's no actual socialising backing it up.
+
+Instead, by increasing the number of people we're likely to meet day-to-day, we give our honed social instincts more opportunity to do what they're there to do.
+By training them on lots of people, we'll get a better sense of what it is we're after in the first place.
+It's more effort to organise and to engage in, but it's certainly better for us overall.
+
+## Pursue goals indirectly
+
+Let's re-examine the things we have to do to meet people by chance: encounter new situations with new pople in them, go somewhere that I'd like to be, and be approachable and charming.
+Put this way, don't these maybe sound like goals on their own?
+
+We could directly pursue those other goals, which don't require any chance.
+We each know where we could go to encounter new situations, and if we don't, we could probably find out if we applied ourselves to the problem.
+We each have our insecurities we'd like to work on, to become more confident and outgoing.
+Especially after an isolating pandemic we likely all need the face-to-face practice of being where people are anyway.
+
+I think that directly pursuing a goal like "I want to find a relationship" is something of a façade.
+Achieving it inherently depends on another person (who cannot be controlled) and the circumstances under which we find ourselves together (even in the best case, we need to be lucky).
+That chance aspect is what makes dating so difficult, but also what makes it so rewarding.
+
+## Saving time
+
+Finally, let's examine the time spent on the application itself.
+It's true that, like any number of modern mobile apps, the minimum time investement is very low.
+You can set up a profile in minutes, and from there you can view profiles on the train, in the coffee queue, or taking a dump.
+Because it's so easy to do, it means that *you do it easily*.
+
+Most of us are already chronic smartphone users, and I absolutely count myself among them. 
+It's devastatingly easy to fall into a habit, and once a habit is dug in it will begin to effect how you think.
+What started as a canny time saving becomes a time sink in itself. 
+Not only that, but it also expends our valuable energy making what are ultimately low-value decisions, culminating in decision fatigue.
+A decision-fatigued person no longer has the energy to make energy choices, and so will but succumb to their habits more, reinforcing a vicious, energy-sapping cycle.
+
+I've seen plenty of people find meaningful relationships through dating apps, and I think that's great: it's always nice to see technology bringing people together.
+But any technology has a dark side, and in my personal experience I've seen more of that than the positive with match-makers and other time-saving propositions.
+As a result of that, I tend to prefer old-fi approaches when they're available.
+
+One could argue quite reasonably that the slow path is wasting time, but I think that's a matter of how one frames it.
+Any time you enjoyed, and look back on after as having enjoyed, surely wasn't wasted.
+If I'm taken the "optimised" path, I might be missing out on enjoying the thing in the first place, and if I'm not enjoying it, I can only wonder if I'm missing the point entirely.
+
+---
+
+I didn't reference anything directly, but there are a few books I've been thinking about which motivated this point of view. They are:
+
+* [You Are Not A Gadget](https://www.goodreads.com/en/book/show/6683549-you-are-not-a-gadget)
+* [Homo Deus](https://www.goodreads.com/book/show/31138556-homo-deus)
+* [Zen and The Art of Motorcycle Maintenance](https://www.goodreads.com/book/show/19438058-zen-and-the-art-of-motorcycle-maintenance)

blogs/2023/8/3/croissants-are-shit-past-noon.md

@@ -0,0 +1,111 @@
+# Croissants are Shit Past Noon
+
+![from the window](window.jpg)
+
+I've been living in Paris for the past couple of months and I thought I'd share some of my observations on the place, the language, and the adventure as a whole.
+I've spent most of my adult life living in London, so I'd primarily like to draw some comparisons between the two cities.
+Though there are two [classic](https://en.wikipedia.org/wiki/A_Tale_of_Two_Cities) [books](https://en.wikipedia.org/wiki/Down_and_Out_in_Paris_and_London) comparing them, I'll open this post by admitting I haven't read them, and that's only the start of my ignorance.
+
+## French
+
+I spoke French as a 6 or 7 year old, and went to an international school in the Paris.
+This means I have the [phonemes](https://en.wikipedia.org/wiki/Phoneme) associated with French, for example the trilled 'r' in F**rrr**ance, or the guttural 'yeugh' in meill**eur**.
+However, this is about where my advantages end, much to my chagrin.
+
+In the years since leaving Paris, my French had atrophied, virtually to completion.
+Children are great at picking up accents and languages, but they're great at losing them too, it would seem!
+After a few years of clawing it back - I'll save the details of my approach for another post - I felt comfortable visting France on holiday, ordering things in restaurants and navigating within or between cities.
+I was not prepared for the intensity of spending an entire evening or day speaking nothing but French.
+
+As it turns out, using a language you're not fluent in is **taxing**.
+Trying to keep up with a conversation between natives is Sisyphean, as they'll speak to each other faster than I can parse what's said, let alone try to form a response.
+This isn't the worst thing in the world for myself - I quite enjoy just watching and listening, rather than always taking a vocal part - but I can imagine the dynamic is strange for those I've spent time with in groups.
+
+One-on-one, the situation is a little better.
+I can't be more than a phrase or two behind in context, and if I've not understood something or make a nonsensical reply, it's an opportunity to check in and get myself back on firm ground.
+The flipside is that I've no chance to recuperate.
+On one evening, I went to a friend's house, had a beer, and played some chess.
+We spoke in French the whole time, and it was a pleasant evening.
+However, as it started to get late, I started to flag - I was slow to understand what he said, and even slower to put together a response.
+As he walked me back to the metro station, he asked if I'd get home OK, to which I could barely manage a 'oui'!
+Once on the train, the language-parsing part of my brain no longer in demand, I felt almost immediately more energetic.
+I hadn't expected the impact of speaking another language for an extended period to be quite so physical, so visceral.
+
+I'm very grateful to the few friends I've made here for putting up with me, though they all speak better English than I do French. 
+I'm also humbled.
+The UK has a large immigrant population, all of whom have had to learn English.
+People speaking accented English is so normal and widespread that it's become utterly unremarkable, though it very much is.
+At some point every single one of them has gone through having to spend hours, days or weeks communicating in a language other than their mother tongue, often as a necessity for a job, without even having the fallback that I've had, being an anglophone in Paris.
+
+Overall, my immersion strategy has been successful: I speak far better French than I did at the start of the summer.
+It's developed primarily my ability to speak and listen, rather than to read and write.
+Even then, my command of the grammar and vocubalary hasn't advanced so much as my confidence.
+I think this has been driven in part by necessity.
+In a conversation, you don't have time to translate completely what someone's said, so you draw on context and what little you've parsed in the split-second after the other has spoken.
+This, coupled with a slapped-together reply, has been the unit of practice I've been trying to encounter as much as possible.
+
+Then, it's been driven by having confirmation.
+After putting together some phrase and speaking it, and the next response comes, it's brilliant: I've been understood!
+Though a totally normal thing, every time I'm understood in French is a moment of magic for me.
+Being able to carry and continue conversations on a wide range of topics, without constant faux pas or speaking gibberish, has bolstered my confidence like nothing else.
+
+I feel that on my return to the UK, my continued French learning will be all the more effective as a result of this experience.
+
+## The French
+
+Parisians have a reputation for being rude to outsiders.
+In my experience this hasn't been the case at all, I've found them to be accommodating and (almost overly) polite.
+In London it's rare to greet others on the street, or even to look them in the eye.
+That's not the case at all in Paris, though it's a denser city, and just as metropolitan.
+Walking past people on the stairs in my building, or navigating a shop, or public transport, people are always sure to say hello, and to wish each other a nice day on departure.
+There are more smiles in Paris than London.
+
+They're very ready to talk about politics, language, culture, France itself of course and are very open on a number of topics I'm too British to risk mentioning here.
+I think the notion of their rudeness is a misinterpretation of what is actually directness.
+The British operate a social culture of subterfuge and doublespeak, whereby it's common to express your displeasure to someone and for them to receive it with a smile, left to understand the reproach only later, or never.
+The French play no such game: they say what they think.
+Personally, I'm a fan of this direct approach.
+I find it hard enough to determine what someone means even when they're not trying to hoodwink me.
+With the French, I'm much less worried that someone may be or have been duplicitous.
+
+The stereotype of a smoking, drinking Frenchie, I'm sad to say, holds no water at all. Of the friends and acquiantances I've made, not a single one has smoked, only a handful have had alcohol and a good number of them have even been vegan.
+
+## The Lifestyle
+
+Parisian authorities have a concept of a ['15 minute city'](https://www.thelocal.fr/20230215/what-is-a-15-minute-city-and-how-is-it-working-in-paris).
+The idea is that one's daily needs should be within 15 minutes of where they live.
+For my flat in central Paris, this is absolutely true.
+This is true even to the extent that Gare du Nord, my link back to London, is but 10 minutes on the metro from where I sleep.
+Combined with the fact that metro lines run quite comfortably in to the early hours makes travel in and around the city faster, cheaper and dare I say even more convenient than that in London.
+
+The French prioritisation of lifestyle over personal assiduity is clear as every night, weekend or otherwise, the eateries and bars are packed to the brim.
+Even walking around to find bites for lunch, the brasseries are packed, and on any evening even approaching warmth the shores of the Seine are shoulder-to-shoulder.
+
+The necessary ingredients for such a lifestyle are easily accessible, too; a coffee, croissant and a baguette - breakfast and most of the way to lunch - together cost less than a coffee on its own would in London.
+Wine is readily available in almost every building with a door and far cheaper than a London pub.
+Beer is the only loser here, which is still about blow-for-blow for when you're out in Soho.
+
+The emphasis on freshness is palpable in a way one doesn't find in the UK - indeed, 'fresh' is a bit of a stretch for any food item in the country at the moment.
+For most of my working life I've tended to take lunches quite late, but am having to adapt my strategies here.
+If I fancy a pastry, I'm sure to get them in the morning.
+From the same chain boulangerie, I made the mistake the other day of buying a croissant at 16h, or four in the afternoon, and it was horrible.
+The same bakery has served me plenty of delicious ones both before and after, but at that time in the afternoon it was dry as a bone, and the butter in it tasted almost salty.
+
+## Isolation
+
+Though a fascinating, enjoyable and productive linguistic and cultural experience, I have experienced more homesickness than I expected to.
+The last time I moved to a city alone was to the Midlands for university, but I quickly made friends on my course and made use of university societies.
+
+It is much more difficult here.
+
+Not only is it a new city and a new language, but as an adult in full-time work wanting to make adult friends who'll also be in full-time work, my opportunities for making friends are painfully finite.
+When I do have time to find and make new friends, I still have to contend with plain old exhaustion.
+
+This is also my first experience living alone for an extended stretch.
+Again, though informative and an experience I'm grateful for, I think I'd prefer to live with others.
+
+I've enjoyed my time in France, and plan to make the most of my last few weeks, but there is a part of me that I didn't expect to pine as much as it has for home.
+
+À la prochaine!
+
+![jacques](jacques.jpg)

build/index.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+
+import sys
+import re
+
+# we expect the arguments to be filepaths to each blog post
+
+def print_usage():
+    print("\nusage: python mkblogindex.py POSTS\n")
+    print("\n")
+    print("\t\tPOSTS\tfilepaths of blog posts")
+
+# check args for at least one file path
+if len(sys.argv) < 2:
+    print_usage()
+    sys.exit(1)
+
+# posts are arguments from index 1 onwards
+posts = sys.argv[1:]
+
+dir_pattern = re.compile("(.+)\/(\d{4}\/\d+\/\d+\/.+\.html)")
+path_pattern = re.compile("(.+)\/(\d{4})\/(\d{1,2})\/(\d{1,2})\/(.+).html")
+title_pattern = re.compile("<h1>(.+)</h1>")
+
+# filter posts to just those with a date in them
+posts = [p for p in posts if path_pattern.match(p)]
+posts.reverse()
+
+links = []
+
+# for each file we want to output an <a> tag with a relative href to the site root
+for path in posts:
+    m = re.match(path_pattern, path)
+    year = m.group(2)
+    month = m.group(3).rjust(2, '0')
+    day = m.group(4).rjust(2, '0')
+
+    date = f'<span class="post-date">{year}-{month}-{day}</span>'
+
+    title = ""
+    with open(path) as f:
+        for line in f:
+            if title_pattern.match(line):
+                title = re.sub(title_pattern, r'<span class="post-title">\1</span>', line).strip()
+                break
+
+    # clean leading directories to get the relative path we'll use for the link
+    url = re.sub(dir_pattern, r"\2", path)
+    url = f"blog/{url}"
+
+    item = (date, f'<li><a href="{url}">{date}{title}</a></li>')
+    links.append(item)
+
+# make sure we're properly ordered in reverse date order lol
+links = sorted(links, key=lambda x: x[0])
+links.reverse()
+
+for l in links:
+    print(l[1])
+

build/page.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import markdown
+import re
+
+#   SRC
+#   +-2022/
+#   | +-10/
+#   | +-12/
+#   |   +-25/
+#   +-2023/
+#   | +-1/
+#   |   +-26/
+#   | +-3/
+#   ... 
+
+def print_usage():
+    print("\nusage: python mkblog.py SRC DEST\n")
+    print("\n")
+    print("\t\tSRC\tinput markdown file")
+    print("\t\tDEST\tdestination html file")
+
+# check args
+if len(sys.argv) != 3:
+    print_usage()
+    sys.exit(1)
+
+src_file = sys.argv[1]
+dest_file = sys.argv[2]
+
+# check blog root exists
+if not os.path.isfile(src_file):
+    print("{blog_root} doesn't exist")
+    sys.exit(1)
+
+# make dest dir if it doesnt exist
+
+dest_dir = os.path.dirname(dest_file)
+print(dest_dir)
+if not os.path.isdir(dest_dir):
+    os.makedirs(dest_dir)
+
+# write markdown into a dummy file first so that we can add lines before it in the final output
+dummy_file = f"{dest_file}.bak"
+open(dummy_file, 'w').close()
+
+print(f"{src_file} -> {dummy_file}")
+markdown.markdownFromFile(input=src_file, output=dummy_file, extensions=["fenced_code"])
+
+# TODO: a lot of this templating work is specific to the ktyl.dev blog - ideally, that stuff should
+# be in *that* repo, not this one
+print(f"{dummy_file} -> {dest_file}")
+with open(dummy_file, 'r') as read_file, open(dest_file, 'w') as write_file:
+    write_file.write("#include blogstart.html\n")
+
+    # modify the basic html to make it nicer for styling later
+    html = read_file.read()
+
+    # extract images from their enclosing <p> tags and put them in img panels
+    html = re.sub('(<p>(<img(?:.+)/>)</p>)', r'<div class="img-panel">\2</div>', html)
+
+    # wrap <ul> elements with <p> to get them into blocks
+    html = re.sub('(<ul>(\n|.)*</ul>)', r'<p>\1</p>', html)
+
+    # insert text-panel start between non-<p> and <p> elements
+    html = re.sub('((?<!</p>)\n)(<p>)', r'\1<div class="text-panel">\n\2', html)
+    # insert para-block end between <p> and non-<p> elements
+    html = re.sub('(</p>\n)((?!<p>))', r'\1</div>\n\2', html)
+
+    # insert code-panel start before <pre> elements
+    html = re.sub('(<pre>)', r'<div class="code-panel">\n\1', html)
+    # insert code-panel end after </pre> elements
+    html = re.sub('(</pre>)', r'\1\n</div>', html)
+
+    # replace horizontal rules with nice separator dot
+    html = re.sub('<hr />', r'<div class="separator"></div>', html)
+
+    lines = html.split("\n")
+
+    # tack on a closing div because we will have opened one without closing it on the final <p>
+    lines.append("</div>")
+
+    for line in lines:
+        write_file.write(line + "\n")
+
+    write_file.write("\n#include blogend.html\n")
+
+os.remove(dummy_file)
+

build/rss.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+
+import markdown
+import pathlib
+import sys
+import re
+
+def print_usage():
+    print("\nusage: python mkblogrss.py POSTS\n")
+    print("\n")
+    print("\t\tPOSTS\tfilepaths of blog posts")
+
+# check args for at least one file path
+if len(sys.argv) < 2:
+    print_usage()
+    sys.exit(1)
+    
+# posts are arguments from index 1 onwards
+posts = sys.argv[1:]
+
+# header and footer to enclose feed items
+header = """<?xml version="1.0" encoding="utf-8" ?>
+<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0">
+<channel>
+    <title>ktyl.dev</title>
+    <link>https://ktyl.dev/blog/index.html</link>
+    <description>mostly computer stuff!</description>
+    <atom:link href="https://ktyl.dev/blog/index.xml" rel="self" type="application/rss+xml"/>
+    """
+footer = "</channel></rss>"
+
+# regex patterns
+title_pattern = re.compile("<h1>(.+)</h1>")
+path_pattern = re.compile("(.+)\/(\d{4})\/(\d{1,2})\/(\d{1,2})\/(.+).md")
+
+def make_item(path):
+    str = "<item>\n"
+
+    # get the HTML version of the file
+    text = ""
+    with open(path) as f:
+        text = f.read()
+    html = markdown.markdown(text, extensions=["fenced_code"])
+
+    # title
+    title = ""
+    m = title_pattern.match(html)
+    title = m.group(1)
+    str += f"<title>{title}</title>\n"
+
+    # link
+    url = "/".join(pathlib.Path(path).parts[1:])
+    url = url.replace(".md", ".html")
+    link = f"https://ktyl.dev/blog/{url}"
+    str += f"<link>{link}</link>\n"
+
+    # content
+    description = html
+    description = re.sub('<', '&lt;', description)
+    description = re.sub('>', '&gt;', description)
+    str += f"<description>{description}</description>\n"
+
+    # pub date
+    date = re.sub(path_pattern, r'\2-\3-\4', path)
+    str += f"<pubDate>{date}</pubDate>\n"
+
+    str += "</item>"
+
+    return str
+
+# print everything!
+print(header)
+for p in posts:
+    print(make_item(p))
+print(footer)
+

makefile

@@ -3,21 +3,44 @@ OUT_DIR		= out/
 HTML_DIR 	= $(OUT_DIR)html
 GEMINI_DIR	= $(OUT_DIR)gemini
 
-MAKE_GEMINI	= build/markdown2gemini.py
+MAKE_GEMINI		= build/markdown2gemini.py
-MAKE_HTML 	= build/markdown2html.py
+MAKE_HTML 		= build/page.py
+MAKE_RSS		= build/rss.py
+MAKE_HTML_INDEX	= build/index.py
 
 PAGES = $(shell find $(SRC_DIR) -wholename "$(BLOG_SRC_DIR)*.md")
 
 HTML_TARGETS 	= $(PAGES:$(SRC_DIR)/%.md=$(HTML_DIR)/%.html)
+HTML_RSS		= $(HTML_DIR)/index.xml
+HTML_INDEX		= $(HTML_DIR)/index.html
+
 GEMINI_TARGETS	= $(PAGES:$(SRC_DIR)/%.md=$(GEMINI_DIR)/%.gmi)
 
+IMAGES		= $(shell find $(SRC_DIR) -wholename "$(SRC_DIR)*.png" -o -wholename "$(SRC_DIR)*.jpg")
+PNG_TARGETS	= $(IMAGES:$(SRC_DIR)/%.png=$(HTML_DIR)/%.png)
+JPG_TARGETS	= $(IMAGES:$(SRC_DIR)/%.jpg=$(HTML_DIR)/%.jpg)
+IMAGE_TARGETS = $(PNG_TARGETS) $(JPG_TARGETS)
+
 _dummy := $(shell mkdir -p $(HTML_DIR) $(GEMINI_DIR))
 
 $(HTML_DIR)/%.html: $(SRC_DIR)/%.md
-	python $(MAKE_HTML) $< $@
+	pipenv run python $(MAKE_HTML) $< $@
 
-html: $(HTML_TARGETS)
+$(HTML_RSS): $(PAGES)
-	echo $(HTML_TARGETS)
+	pipenv run python $(MAKE_RSS) $(PAGES) > $@
+
+$(HTML_INDEX): $(HTML_TARGETS)
+	pipenv run python $(MAKE_HTML_INDEX) $(HTML_TARGETS) > $@
+
+$(HTML_DIR)/%.png: $(SRC_DIR)/%.png
+	mkdir -p $(shell dirname $@)
+	cp $< $@
+
+$(HTML_DIR)/%.jpg: $(SRC_DIR)/%.jpg
+	mkdir -p $(shell dirname $@)
+	cp $< $@
+
+html: $(HTML_TARGETS) $(HTML_RSS) $(HTML_INDEX) $(IMAGE_TARGETS)
 
 gemini: