• Figuring what I wanted it to be about.
• Deciding whether or not it would be worth doing, or if I’d even have any content worth posting.
• Deciding how it should look.
• Deciding what it should include.
• Deciding how it should be hosted.
• Testing and execution.

Initial Plans

My initial plans were to setup a blog to practice writing, and have a place to share my notes and thoughts in a more meaningful way that was under my control and not just by posting on Instagram into the ether. An added benefit would be to learn a bit more about software development, and to implement some basic CI/CD practices.

My first steps included:

1. Setting the site up functionally.
2. Creating a CI/CD pipeline for server updates after code changes are tested.
3. Integrating my org-mode notes directly into the website.

For the last point, I wanted a system in which I could write something in org-mode (where I use the denote packages), and then be able to press a few keybinds to export the note or post into an appropriate format (in this case, a Markdown file), into the directory that my site is hosted. This would minimise any friction between my preferred writing environment, and the update of the blog.

Settling on the Astro Framework

After doing a bit of research on other static blogs, it seemed like the Astro framework was a good place to start. Particularly as I saw that there were some examples of others using Astro integrated with Emacs ox-hugo exports.

Some of the benefits with Astro that I noticed are that it:

• Generates static websites, so a backend is not needed;
• Takes Markdown files as inputs and outputs HTML;
• Uses JavaScript, so I can take libraries from the npm ecosystem.

Steps to run Astro Website in NixOS

NixOS has been my Linux distro of choice, so I started with the below.

1. Run nix develop with the following flake.nix to enable NodeJS.

   {
     description = "A Nix-flake-based Node.js development environment";
   
     inputs.nixpkgs.url = "https://flakehub.com/f/NixOS/nixpkgs/0.1.*.tar.gz";
   
     outputs = { self, nixpkgs }:
       let
         overlays = [
           (final: prev: rec {
             nodejs = prev.nodejs_latest;
             pnpm = prev.nodePackages.pnpm;
             yarn = (prev.yarn.override { inherit nodejs; });
           })
         ];
         supportedSystems = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ];
         forEachSupportedSystem = f: nixpkgs.lib.genAttrs supportedSystems (system: f {
           pkgs = import nixpkgs { inherit overlays system; };
         });
       in
       {
         devShells = forEachSupportedSystem ({ pkgs }: {
           default = pkgs.mkShell {
             packages = with pkgs; [ node2nix nodejs pnpm yarn ];
           };
         });
       };
   }
   

2. Create a directory for your project and run npm create astro@latest.

3. Enter the directory of the initialised Astro project, and run npm run dev.

Initial Thoughts with Astropaper Theme

My first test was with the Astropaper theme. I ported over some of my early tests with Markdown files with images of a few of my bonsai trees but overall the theme felt rather… heavy.

I found that the theme offered a lot of features, and lot’s of different configuration elements but I none of them felt really necessary for me. Another gripe was that converting from my org-mode files to Markdown presented a lot of friction, in that I needed to figure out a special way to generate the required header file in the Astropaper template, and finally, have to shift all of my headings down one level as Astropaper used level 1 headings for titles.

This ended up as an ~2 hour experiment, and I then moved on to trying out a Hugo website with ox-hugo, an Org to Hugo exporter.

Detour with Emacs + Org Mode + Ox-Hugo

At first, it seemed like ox-hugo in conjunction with Nix would be a nice combination to move forward based on this website example https://shom.srht.site/ .

There were various good references that I found using Hugo including:

• One with the use of denote and hugo.
• A reference for ox-hugo, gitlab and netlify.
• One with a photo gallery that would have been useful to implement for my photography.

Hugo Test

I ran some tests, and enjoyed the workflow with Hugo, but eventually lost interest as the site and theme didn’t speak to me on an aesthetic level and it also didn’t seem like a good fit for implementing photography.

1. Install hugo, which can be done temporarily in nix with nix-shell -p hugo.

2. Create a new Hugo site with the PaperMod theme.

   hugo new site quickstart
   cd quickstart
   git init
   git submodule add --depth=1 https://github.com/adityatelange/hugo-PaperMod.git themes/PaperMod
   echo "theme = 'PaperMod'" >> hugo.toml
   hugo server
   

3. New content can be created using the hugo CLI command, or by simply adding files into the relevant directory.

hugo new content content/posts/my-first-post.md

By default, the front matter will have a draft value of true. By default Hugo does not publish draft content when building the site so take note of this.

Draft content can be built by running hugo server --buildDrafts or with hugo server -d.

astro-chiri

I’m not sure where I stumbled upon astro-chiri a few months ago, but recently I opened up my blog working folders with a newfound inspiration and have decided that this feels right. With a bit of help from Claude Code I sorted out minor issues I had with the theme, and have also implemented a workflow as planned from Emacs org-mode.

The current setup will be outlined in the next post.

1. SSH to Edit Remote File
   1. Emacs Sudo Issues and SSH Privileges
   2. Issues accessing remote machine with fancy prompt

SSH to Edit Remote File

Use the find file function with SPC f . and enter the following pattern:

/ssh:<username>@<remotehost>:/<path>/<to>/<file>

Emacs Sudo Issues and SSH Privileges

Your Tramp session inherits whatever privileges belong to the user you logged in as. If you log in as the root user, you have complete access to your server.

Otherwise, you would need to pass sudo privileges into your session:

/sudo::/path/to/file

Issues accessing remote machine with fancy prompt

I’m using ZSH, with some custom config and it appears that this is what is causing my issues logging into machines using tramp, as logging in via root works fine.

This is explained further in sources below: https://stackoverflow.com/questions/6954479/emacs-tramp-doesnt-work https://www.bounga.org/tips/2017/11/30/fix-emacs-tramp-lag-and-timeout/

The most simple fix is to include the following in .zshrc on the remote machine.

if [[ $TERM == "dumb" ]]; then
    export PS1="$ "
fi

There is another source which mentions issues with something called ZLE as reported in the Tramp manual. This suggests adding the following:

[ $TERM == "tramp" ]] && unsetopt zle && PS1='$ ' && return

When Tramp connects to a remote host it sets the TERM environment variable as dumb so you know you’re in the situation were you want a really simple prompt. What to do then is to set the prompt to a simple “$ “ string.

EmacsWiki describes the problem as follows:

If you are using zsh, the zle option can cause this behaviour. The Tramp manual does actually note this in 4.16 Remote shell setup hints, and provides a possible workaround there (namely, if you tell TRAMP you’re using zsh, it will automatically supply some extra flags to configure things appropriately; you can see the flags it uses in tramp-sh-extra-args).

Additionally, with the default settings, using sshx rather than ssh will likely work because it will tell the remote host to run /bin/sh instead of zsh.

Build

Frame

50cm Midnight Special in Fool’s Gold - pretty rare to see. I chose the Midnight Special because it’s a steel bike with the look of an old school race bike, but with clearance for wide tyres, 700c x 42mm and 650b x 60mm. It has a great smooth ride that is pretty responsive when putting down the power and I don’t feel like it lacks much in that department compared to my Focus Paralane. 54cm felt a bit too large, and based off Reddit comments it seems like people my height went for the 50cm. Turns out this is a more aggressive geometry, even in the smaller size compared to my 54cm Focus Paralane. After some time on the bike, I’m getting used to the riding position. Eventually I might try getting a bike fit but after some tweaks I’m riding pain-free on 2+ hour rides.

Groupset

Scored a full GRX820 groupset that came off a Cannondale SuperX Carbon bike that was getting SRAM put on it for a cyclocross race. This meant I got a great deal on a high-level groupset that had been installed on a bike but never ridden. This included:

• Shimano GRX820 - 2x12
• 48-31T, 170mm cranks
• 11-34T Ultegra cassette
• RT-CL800 160mm C/Lock rotors
• SMR60 bottom bracket

This setup is an upgrade over the stock Surly Midnight Special 2x12 105 groupset which would have been more road-oriented. The GRX adds a clutch which adds tension to the chain reducing the chance of the chain coming off on bumpy terrain, and easier gearing for hills.

Saddle, Seatpost and Cockpit

The seatpost and cockpit are all from the Ritchey comp lineup, which matches the theme with light grey branding logos against matte black. These are good value, don’t weigh too much and look great. The saddle is by Fabric and one I took from my old bike. It came with the prior purchase and works well for me.

Bartape

Grepp bartape in Ultimate Grey. This is a cloth bartape that is washable and re-usable. It doesn’t have as much padding as regular rubber/cork bartape but adds a nice point of difference and suits an all-road and gravel bike well. The grey is a super light in colour and adds a nice pop of contrast to the bike.

Pedals

Simworks Tiny Bubbly flat pedals for my day-to-day commute. I was looking for pedals on the smaller side, that had a more modern and refined look. These spin great, feel great and look great although the one downside is things can get a bit slippery when there’s any moisture involved. They’re perfect for everyday riding but now I’ve done some more longer distance rides, and bumpier ride on gravel and single track, I can see the benefit in a clipless system.

Tyres

Rene Herse Barlow Pass 38mm. Tossed up between this and Panaracer Gravelking Semi Slicks. Rene Herse tyres are known for their fast rolling performance and suppleness, making them suitable for of different kinds of terrain. Initially thought I’d be doing 80/20 road/gravel riding split but that is more like a 50/50 split at the moment so the Gravelkings may have been the better choice! In future I could get a pair of 650b wheels and put on some proper wide and knobbly tyres if my gravel adventures continued to get a bit more serious. That’s another benefit of the frame.

Bottle Cages

Minoura bottle cages in silver that match up with the bartape and Ritchey branding. This is a well-priced option. I could upgrade these to something fancier, but $50+ for a titanium bottle cage seems a bit much!

Acquired on: 2024-05-25

Overview

Itoigawa Junipers are a native variety in Japan that are known to be quite hardy, with bright green dense foliage. It grows quickly and is also often grafted on to old Shimpaku stock.

This tree was purchased from a Yarra Valley Bonsai Society sale from Shibui Bonsai. Itoigawa’s are quite rare to see in Australia, and bonsai enthusiasts such as Shibui and Bonsai Sensation have only recently started to put stock up for sale after many years cultivating and developing them.

Progress Updates

2024-05-25

• Acquired the tree from Yarra Valley Bonsai Society sale.

2024-06-01

• Repotting: Repotted into a larger container.

2024-06-23

• Wiring and Style: Initial wiring and style applied to accentuate and set movement in the branches. A significant amount of foliage was removed. I am slightly concerned about the removal, as it’s often advised not to defoliate evergreen trees as much as deciduous trees since the energy of the tree is in its foliage.
• Monitor tree response in spring to ensure it bounces back well.

2025-08-28

• The tree responded well and grew throughout the year. It is not about to enter spring and I will leave it’s foliage to strengthen and grow vigorously. Next cut back might happen at the end of spring coming into summer. If it has too much foliage in summer, it might take up too much water and leave the pot dry which would be dangerous for the tree.
• Have refreshed the fertiliser. Prior fertiliser was placed last spring and left for the year to get used up.

1. Convert FLAC files in a folder to 320kbps MP3 files recursively.
2. Import music albums represented as folders in a given folder into my music library using beets.

Bash Script

#!/bin/bash
# Script to convert FLAC files from a given directory, and then import using beets
# This environment is run from WSL, where beets is running on the host Windows machine (legacy reasons)

default_win_folder="C:\Users\username\Music"
default_wsl_folder="/mnt/c/Users/username/Music"
arr=()

# Function to convert FLAC files to MP3
convert_flac_to_mp3() {
    for item in "${arr[@]}"; do
        flac_file="$item"
        mp3_file="${flac_file%.flac}.mp3"
        echo "Converting: $flac_file -> $mp3_file"
        # ffmpeg conversion command for 320kbps and to keep metadata
        ffmpeg -i "$flac_file" -ab 320k -map_metadata 0 -id3v2_version 3 "$mp3_file"
    done
}

# Clean up FLAC files after converting
delete_old_flac() {
    rm "${arr[@]}"
}

# Function to iterate through subfolders recursively
iterate_subfolders() {
    folder="$1"

    echo "Found Album or Folder: $folder"

    # Iterate through all files and folders in the given folder
    for item in "$folder"/*; do
        if [ -d "$item" ]; then
            # If it's a subfolder, call the function recursively
            iterate_subfolders "$item"
        elif [ -f "$item" ] && [[ "$item" == *.flac ]]; then
            # Add to list of identified FLAC files
            arr+=("$item")
        fi

    done

    if [ -n "$arr" ]; then
        echo "Found the following FLAC files in folder:"
        printf "%s\n" "${arr[@]}"
        read -p "Convert files in folder? (y/n): " choice
        case "$choice" in
            y|Y ) convert_flac_to_mp3; echo "Conversion of files completed for $folder.";;
            * ) echo "Skipping folder: $folder";;
        esac
        read -p "Delete FLAC files in $folder? (y/n): " choice
        case "$choice" in
            y|Y ) delete_old_flac;;
            * ) echo "Skipping folder: $folder";;
        esac

        # Clear array
        arr=()
    else
        echo "No FLAC files found in this folder, skipping."
    fi
}

# Main script

# Ask for the folder path
read -p "Enter directory (1) or use default (0) '$default_wsl_folder'?" choice
case "$choice" in
    0 ) folder_path=$default_wsl_folder;;
    1 ) read -p "Enter the folder path to search for FLAC files: " folder_path;;
    * ) echo "No valid input.";;
esac

# Check if the folder exists
if [ ! -d "$folder_path" ]; then
    echo "Folder not found!"
    exit 1
fi

# Call the function to iterate through subfolders
iterate_subfolders "$folder_path"

# Run beet import
echo "Running beet import $default_win_folder now. You may need to provide some inputs."
powershell.exe "beet import $default_win_folder"

Btrfs is a modern copy on write (CoW) filesystem for Linux aimed at implementing advanced features while also focusing on fault tolerance, repair and easy administration.

As usual, head to the Arch Wiki for a good summary of working with btrfs. Btrfs - ArchWiki

Subvolumes

Commands

Creating a subvolume

To create a subvolume:

btrfs subvolume create /path/to/subvolume

Listing subvolumes

To see a list of current subvolumes and their ids under path:

btrfs subvolume list -p path

Deleting a subvolume

To delete a subvolume:

btrfs subvolume delete /path/to/subvolume

Since Linux 4.18, one can also delete a subvolume like a regular directory (rm -r, rmdir). Mounting subvolumes

Mounting a subvolume

Subvolumes can be mounted like file system partitions using the subvol=/path/to/subvolume

Displaying filesystem used/free space

General linux userspace tools such as df(1) will inaccurately report free space on a Btrfs partition. It is recommended to use btrfs filesystem usage to query Btrfs partitions. For example, for a full breakdown of device allocation and usage stats:

btrfs filesystem usage /

Snapshots

“A snapshot is simply a subvolume that shares its data (and metadata) with some other subvolume, using btrfs’s COW capabilities.”

To create a snapshot:

btrfs subvolume snapshot source [dest/]name

To create a readonly snapshot add the -r flag. To create writable version of a readonly snapshot, simply create a snapshot of it.

Note: It is possible for a snapshot to be converted in-place from readonly to writeable. However, this is not recommended because it causes issues with any future incremental send/receive. Making a new writeable snapshot prevents such issues. Snapshots are not recursive. Every nested subvolume will be an empty directory inside the snapshot.

Snapper

Snapper is a tool created by openSUSE’s Arvin Schnell that helps with managing snapshots of Btrfs subvolumes and thin-provisioned LVM volumes. It can create and compare snapshots, revert between snapshots, and supports automatic snapshots timelines. Snapper - ArchWiki

Booting into Snapshots

In order to boot into a snapshot, the same procedure applies as for mounting a subvolume as your root partition, as given in section mounting a subvolume as your root partition, because snapshots can be mounted like subvolumes.

If using GRUB you can automatically populate your boot menu with btrfs snapshots when regenerating the configuration file with the help of grub-btrfs or grub-btrfs-gitAUR. If using rEFInd you can automatically populate your boot menu with btrfs snapshots with the help of refind-btrfsAUR, after enabling refind-btrfs.service.