Workbench

Exporting Org Mode to Markdown with Yaml Frontmatter

Andy Chase — Wed, 20 May 2026 20:00:00 +0000

Exporting Org Mode to Markdown with Yaml Frontmatter

Most static site generators use Markdown as their input format.

Org mode's built-in Markdown exporter works quite well, and ox-gfm gives you the extra bells and whistles supported by GitHub flavored Markdown.

There are two problems:

Problems

Static site generators rely on YAML frontmatter for document metadata

For example:

---
title: Hello World
description: A brief description of this content
date: 2026-05-21
tags: foo, bar, bat
---

Various org-to-markdown exporters have lousy support for frontmatter

(There is ox-hugo, but it uses various structural conventions that quickly get frustrating if you're not using Hugo.)

A Lazy Solution Hack

An elisp function to provide better frontmatter support is on my one-of-these-days lists, but in the meantime, if you can live it and if you don't mind using ox-gfm, you can just define your frontmatter as an export block at the top of the org files you want to export to markdown:

#+BEGIN_EXPORT markdown
---
title: Inline YAML Frontmatter
description: It's ugly but it works
---
#+END_EXPORT

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam ante erat, sollicitudin ac elit in, accumsan sollicitudin nunc. Mauris consequat tincidunt facilisis. Maecenas ut mi diam. In vehicula ipsum sed purus semper, ut porta nisi bibendum. Pellentesque in est tristique, hendrerit enim non, sodales mauris. Fusce ut nulla placerat nisi elementum tempor. Donec imperdiet mollis odio, dictum posuere nulla bibendum congue. Sed sapien justo, molestie id convallis a, dapibus sit amet mauris. Sed malesuada faucibus erat eget dignissim. Mauris lacinia nunc eu gravida blandit. Nullam viverra diam vel tincidunt aliquam. Proin at accumsan turpis, iaculis malesuada odio. Pellentesque id faucibus augue.

Fusce et libero sed est porttitor dignissim. Quisque rhoncus lacus ac laoreet interdum. In tortor libero, ultricies vitae accumsan nec, mattis vel orci. Quisque facilisis tincidunt mi, at mattis ipsum cursus eu. Donec faucibus a ante ac volutpat. Etiam dui eros, pulvinar congue accumsan ac, ultrices et eros. Aliquam non vehicula tortor, ut laoreet nisi. Nulla facilisi. Phasellus vel bibendum mi. Donec a urna nisi. Pellentesque tempus nunc et tellus convallis eleifend.

(ox-gfm is necessary because the native ox-md exporter helpfully converts occurrences of --- into emdashes.)

Formatting a Cheap Generic MicroSD Card For the Digitech Trio+

Andy Chase — Wed, 13 May 2026 20:00:00 +0000

Formatting a Cheap Generic MicroSD Card For the Digitech Trio+

I purchased a couple of cheap no-name MicroSD cards for use with my Trio+ pedal. According to the manual, the Trio+ should automatically handle formatting a new card when powered on, but I was getting the flashing red Part LEDs that indicate a problem with the media.

Checking the format of a known good card

I mounted^[1] the Trio+ card I was already using in MacOS and ran diskutil list, which revealed:

/dev/disk4 (internal, physical):
 #:                       TYPE NAME                    SIZE       IDENTIFIER
 0:     FDisk_partition_scheme                        *7.9 GB     disk4
 1:                 DOS_FAT_32 TRIOPLUS                7.9 GB     disk4s1

Checking the format of the new card

diskutil list showed a couple of differences:

/dev/disk4 (internal, physical):
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:     FDisk_partition_scheme                        *7.8 GB     disk4
   1:             Windows_FAT_32 NO NAME                 7.8 GB     disk4s1

From what I understand, diskutil on MacOS supports a single FAT32 filesystem type, and DOS_FAT_32 and Windows_FAT_32 are both aliases for it. (I have no idea why diskutil read the two different cards differently.)

Reformatting the new card

Making EXTRA SURE that I was using the new empty card and not my old one with a bunch of song data on it, I ran:

diskutil erasevolume FAT32 "TRIOPLUS" disk4s1

after which diskutil list displayed:

/dev/disk4 (internal, physical):
 #:                       TYPE NAME                    SIZE       IDENTIFIER
 0:     FDisk_partition_scheme                        *7.8 GB     disk4
 1:                 DOS_FAT_32 TRIOPLUS                7.8 GB     disk4s1

When I put the freshly formatted card into the Trio+ and powered it on, the card mounted as expected: the 'Part' lights came on in an a sequential amber pattern for a few moments and then the pedal finished booting as normal.

Make sure your full-size SD card adapter works; the cheap no-name card came with one, but when I tried using it MacOS didn't see it at all. I switched to a Sandisk adapter I had lying around and that worked. ↩︎

Directionally Aware Collision Detection in Pico-8

Andy Chase — Sat, 03 Jan 2026 19:00:00 +0000

Directionally Aware Collision Detection in Pico-8

Notes on detecting which side of the hit box a sprite has hit for the Pico-8 fantasy console

I've been tinkering with Pico-8 lately and I find myself wanting to be able to detect collisions between a sprite and a map tile, and change the sprite direction accordingly (basically the same "bouncing ball" behavior you see in a lot of intro lessons, where a ball is moving on a diagonal and reverses X direction if it hits the side of the screen, or Y direction if it hits the top or bottom.

Basic Collision Detection

There are some good Pico-8 collision detection how-tos out there:

PICO-8 Collision Function (very small function that test whether the map tile at x, y has a given flag)
Simple Collision Function
First Steps in PICO-8: Easy Collisions with Map Tiles

...but these only return a boolean indicating a collision state; there's no way to determine which side the collision has happened on.

Determining Directionality

Their function uses slopes to compare the angle of the sprite to the nearest corner of the hitbox, where the nearest corner is determined by which geometric quadrant the sprite is moving towards.

TeamworkCast implements a function that determines whether an object is colliding vertically or horizontally as part of their Breakout clone series on YouTube, in video #7^[1].

There are some subtleties involved in actually integrating this function as well, and those are covered in video #8.^[2]

Video: https://www.youtube.com/watch?v=AGblHq-ZamI, Code: https://pastebin.com/dCRQsXTJ ↩︎
Video: https://www.youtube.com/watch?v=fBi6vPcFmJ4 ↩︎

Note to Self: Networking Edition

Andy Chase — Thu, 18 Dec 2025 19:00:00 +0000

Note to Self: Networking Edition

Networking things I am perpetually having to look up how to do

Get a List of Every IP on a LAN^[1]

(Where 192.168.1.255 is the current machine's broadcast address)

Using `ping`

arp -a
ping -c 1 192.168.1.255

Using `nmap`

(provides more details)

nmap -sn 192.168.1.0/24

How to see all IP addresses on network: A guide for IT professionals ↩︎

Note to Self: Lilypond Edition

Andy Chase — Wed, 03 Dec 2025 19:00:00 +0000

Note to Self: Lilypond Edition

Vertically Align and Horizontally Space Markup Above the Staff

% This controls the vertical padding between the staff and text.
% (Higher number = more space.)
\override TextScript.staff-padding = #5
% This controls the horizontal space between text items.
% (Useful to force a little extra space between text items
% so they're all on one line)
\override TextScript.extra-spacing-width = #'(-0.5 . +0.5)

(Presumably this should work for markup below the staff too)

Note to Self: ImageMagick Edition

Andy Chase — Tue, 02 Dec 2025 19:00:00 +0000

Note to Self: ImageMagick Edition

(Or, things I am perpetually looking up how to do with ImageMagick)

Notes refer to the ImageMagick 7 magick command-line tool unless otherwise noted.

Generate a Limited Palette From a Source Image

magick <input.png> -colors 64 -unique-colors -scale 1000% <palette.png>

Scale is not necessary if you're just using the palette file for quantization, but it's nice to be able to actually see the colors.

(via Stackexchange)

Apply a Limited Color Palette to an Image

magick <input.png> -remap <palette.png> <output.png>

If you want the resulting image to include a smaller number of colors while still restricting those colors to the palette:

magick <input.png> -remap <palette.png> -colors <n> <output.png>

Harmonize: an app for exploring scales and chords

Andy Chase — Wed, 29 Oct 2025 20:00:00 +0000

Harmonize: an app for exploring scales and chords

This is an app that lets you select a note and scale, and shows you all of the diatonic chords for that scale.

It also allows you to highlight notes, which can be useful for exploring their distribution among those chords.

The app is at /~moondog8/apps/harmonize/ for now.

Source code is at https://codeberg.org/MysteryDevices/harmonize.

Note to Self: Docker Edition

Andy Chase — Mon, 20 Oct 2025 20:00:00 +0000

Note to Self: Docker Edition

Searching and removing Docker images by Repository Name:

docker images "repositoryname/*" --format ":" | xargs docker image rm

Running `yt-dlp` with Cookies

Andy Chase — Wed, 15 Oct 2025 20:00:00 +0000

Running `yt-dlp` with Cookies

yt-dlp --cookies-from-browser firefox:default-release --user-agent "Mozilla/5.0" <url>

Looptober 2025

Andy Chase — Wed, 08 Oct 2025 20:00:00 +0000

Looptober 2025

Somehow it's already October, which means it's time for the informal personal challenge to make a daily-ish loop or short snippet of music for no other reason than that it's good to make music and force yourself not to overthink it.

I'm collecting tracks with Faircamp as I go here, or you can listen with the embedded player below:

Found an Old Friend

Andy Chase — Fri, 29 Aug 2025 20:00:00 +0000

Found an Old Friend

In 2004 I bought this 30 gigabyte iPod from a colleague, and I used it extensively for the next 2-3 years.

I think I stopped using it due to:

Its battery capacity being shot (and no way to power it in the car because it only charges via FireWire port)
Dwindling hardware support for FireWire connectors (at least on devices I owned)
Starting a telecommuting gig that meant far less time spent in the car

I'm reasonably sure I still have the original wall wart, and if I can lay my hands on it I'm going to see if it will power up.

A Bash Alias For Viewing READMEs From the Command Line

Andy Chase — Tue, 22 Jul 2025 20:00:00 +0000

A Bash Alias For Viewing READMEs From the Command Line

It occurred to me that it would be nice to be able to display the contents of a README file in the terminal without knowing the file format or whether it's upper/lower case, and some yak-shaving ensued.

This is a bash alias that:

Makes a temp directory
Looks for any file in the current directory whose name begins with readme
Uses pandoc to convert the first README found into a section 1 man page in the temp directory
Uses sed to add a .TH topic line at the top of the man page, as pandoc does not seem to do this on its own
Displays the man page using the linux-specific -l option (This alias will not work on MacOS, which I assume means it also won't work on FreeBSD)

Prerequisites

man
pandoc
mktemp
sed
xargs

The Alias

Add the following at the end of your ~/.bash_aliases file:

alias readme="RMDIR=`mktemp -d -p ${TMPDIR-/tmp} readme-XXXXXX`; find . -iname 'readme.*' -maxdepth 1 | head -n 1 | xargs  -I {} pandoc {} -o $RMDIR/readme.1;sed -i '1s/^/.TH README 1\n/' $RMDIR/readme.1; man -l $RMDIR/readme.1"

Then either close and reopen your terminal, or type source ~/.bash_aliases.

Now you should be able to cd to a directory containing a README (or Readme.md, or ReadMe.rst, etc) file and type:

readme

to quickly view it.

Chord Navigator, Part 1

Andy Chase — Thu, 05 Jun 2025 20:00:00 +0000

Chord Navigator, Part 1

One of the first apps I purchased on my first smart phone and still use almost daily is Guitar Toolkit, which is an invaluable tool for finding scales and chords for pretty much any stringed instrument in any tuning you could want.

One very helpful feature I didn't notice until a couple of years ago is the ability to look up a scale or mode (D Dorian, for example) and then get a list of all diatonic[^1] chords in the scale.

However... when practicing or fooling around with songwriting or composition I find apps to be quite distracting in a way that dedicated hardware is not, and that got me thinking about making a practice/songwriting/learning device for browsing scales and the chords that sound good with them.

[^1] Chords containing only notes in a given scale

Tangling Org Mode Properties Into Source Code Blocks

Andy Chase — Wed, 14 May 2025 20:00:00 +0000

Tangling Org Mode Properties Into Source Code Blocks

A problem I've been trying to solve on and off for a number of years is: I'd like to be able to consistently generate multiple artifacts (PDF, web graphics, MIDI) from a single Lilypond arrangement and collect multiple arrangements into a single document (using lilypond-book, for example.)

Lilypond supports this up to a point. You can assign chunks of notation to variables and then define multiple \score blocks that re-use them, but I always find myself having to refresh my memory for things like unfolding repeats for MIDI output or transposing an entire score. Things get verbose and repetitive, and not unlike old-school static HTML web sites where tweaking the appearance of something means editing every single page because they all have quirks and inconsistencies.

Enter Org mode, a Swiss-army knife authoring environment/document format that can do all kinds of things. One of its most interesting features is the ability to evaluate/interpolate/export blocks of source code within an Org mode document. Using noweb reference syntax you can insert blocks of code into other blocks of code... in my case I am hoping I can come up with an Org mode template/workflow that will let me focus on just the actual content of arrangements, and use org-babel-tangle to generate lilypond files for different targets (PDF/svg/transposition/MIDI/lytex).

The first problem I needed to solve was being able to reuse properties across source code blocks, and I got it working:

# -*- mode: org; org-confirm-babel-evaluate: nil; -*-
# -*- mode: org; org-use-property-inheritance: t; -*-
:PROPERTIES:
:TITLE: The Quick Brown Fox
:COMPOSER: Arthur \"Two-Sheds"\ Jackson
:COPYRIGHT: 1969
:END:

* Lilypond

#+begin_src lilypond :tangle quick-brown-fox.ly :noweb yes :padline no
  version "2.24"

  \header {
   title = "<<get("TITLE")>>"
   composer = "<<get("COMPOSER")>>"
   copyright = "<<get("COPYRIGHT")>>"
  }

  \score relative c' {
    c d e f
  }
  \layout()
#+end_src

* Markdown

#+begin_src markdown :tangle quick-brown-fox.md :noweb yes :padline no
  # <<get("TITLE")>>

  ## By <<get("COMPOSER")>>, <<get("COPYRIGHT")>>

  Lorem ipsum dolor sit amet
#+end_src


# Helper function that can be used to insert org-mode properties into source blocks:
#+NAME: get
#+begin_src elisp :var prop="title" :results value :exports none
   (prin1 (org-entry-get (point) prop 'selective))
#+end_src

Running org-babel-tangle on this file generates two new files:

quick-brown-fox.ly

version "2.24"

\header {
 title = "The Quick Brown Fox"
 composer = "Arthur \"Two-Sheds"\ Jackson"
 copyright = "1969"
}

\score relative c' {
  c d e f
}
\layout()

and

quick-brown-fox.md

# The Quick Brown Fox

## By Arthur \"Two-Sheds"\ Jackson, 1969

Lorem ipsum dolor sit amet

This is a minimal and not super-useful example but it has promise.

Ciglet: Figlet Comment Blocks

Andy Chase — Thu, 20 Feb 2025 19:00:00 +0000

Ciglet: Figlet Comment Blocks

I often use FIGlet in code comments; if a file I'm working on is particulary large and hairy, big comments can provide useful visual landmarks as you scroll around.

I also like to leave myself a big old temporary

//  _____ ___  ____   ___  
// |_   _/ _ \|  _ \ / _ \ 
//   | || | | | | | | | | |
//   | || |_| | |_| | |_| |
//   |_| \___/|____/ \___/

at the end of the day with some notes about where I left off.

You can easily pipe figlet's output to the pasteboard on MacOS like:

% figlet TODO | pbcopy

...but got tired enough of typing | pbcopy, pasting, and then having to select the newly pasted text and comment it out that I hacked together a Bash script that wraps the figlet command and:

Accepts an additional initial -a argument (a for add) for the comment character you want to use (Defaults to //)
Passes any additional arguments directly to figlet
Pipes the output of figlet into sed to add the comment prefix to each line
Pipes the output of that onto the pasteboard so you can just paste it into your editor. (It also prints it to STDOUT.)

#!/bin/bash

#    _______       __     __ 
#   / ____(_)___ _/ /__  / /_
#  / /   / / __ `/ / _ \/ __/
# / /___/ / /_/ / /  __/ /_  
# \____/_/\__, /_/\___/\__/  
#        /____/              
#
# Figlet Code Comments (MacOS)

# Default prefix
prefix="//"

# Check for -a option first
if [[ "$1" == "-a" && -n "$2" ]]; then
    prefix="$2"
    shift 2
fi

# Escape the prefix for sed
escaped_prefix=$(echo "$prefix" | sed 's/[\/&]/\\&/g')

# Run figlet with all remaining arguments, add prefix, and send to both stdout and pbcopy
figlet "$@" | sed "s/^/$escaped_prefix /" | tee >(pbcopy) 
echo ""
echo "(Copied to clipboard)"

If you save it to an executable file called ciglet somewhere in your PATH, you can run:

ciglet -a '#' -f slant 'Hello, World!'

and you should see

#     __  __     ____           _       __           __    ____
#    / / / /__  / / /___       | |     / /___  _____/ /___/ / /
#   / /_/ / _ \/ / / __ \      | | /| / / __ \/ ___/ / __  / / 
#  / __  /  __/ / / /_/ /      | |/ |/ / /_/ / /  / / /_/ /_/  
# /_/ /_/\___/_/_/\____( )     |__/|__/\____/_/  /_/\__,_(_)   
#                      |/                                      

(Copied to clipboard)

How to get a node.js `Dirent` object directly from a path

Andy Chase — Thu, 07 Nov 2024 19:00:00 +0000

How to get a node.js `Dirent` object directly from a path

I found myself needing a Dirent object for a known path, and as far as I can tell there's no way to instantiate one; although you can do:

const myDirEnt = new Dirent();
myDirent.name = '/path/to/a/file.txt';
myDirent.path = myDirent.parentPath = '/path/to/a/';

The isFile(), isDirectory(), etc. methods all return false.

So, I wrote a function returns a functional Dirent object:

import fs from "fs/promises";

/**
 * Utility function to get a `Dirent` object for a given path without using `fs.readdir`
 */
const getDirent = async (filePath: PathLike): Promise<Dirent> => {
  const stat = await fs.lstat(filePath);
  const pathInfo = path.parse(filePath as string);
  return {
    name: pathInfo.base,
    path: pathInfo.dir,
    parentPath: pathInfo.dir,
    isDirectory: () => stat.isDirectory(),
    isFile: () => stat.isFile(),
    isSymbolicLink: () => stat.isSymbolicLink(),
    isBlockDevice: () => stat.isBlockDevice(),
    isCharacterDevice: () => stat.isCharacterDevice(),
    isFIFO: () => stat.isFIFO(),
    isSocket: () => stat.isSocket(),
  }
}

Stupid Strudel Tricks

Andy Chase — Thu, 24 Oct 2024 20:00:00 +0000

Stupid Strudel Tricks

I found myself wanting to import a helper function into the Strudel REPL for reasons, and I know the thing to do would be to set up my own local custom REPL where I can load whatever I want, but I am lazy and I was also curious whether shenanigans like this would even work.

The answer is yes. I bundled my library into a script that uses an IIFE to assign all of its exports to a global variable, and a common pattern for loading JS code from a remote URL boils down to:

Fetch the script as a Blob
Make an ObjectURL from the blob
Create a new script element with the ObjectURL as its src
Add the new script element to the DOM

And it works! But I'd get an error the first time I evaluated the code, despite awaiting async code... the issue wound up being that I was trying to invoke my imported code before the newly-injected script element had finished loading.

A typical pattern for this is to add a listener to the load event on the script element, and use the callback to invoke your code, but that doesn't seem to play nicely with the Strudel REPL. So, I just resorted to an plain old while loop to wait for the function to be defined (with a timeout to prevent an infinite loop if it doesn't load for some reason)

Altogether, this is what I wound up with:

const res = await fetch('https://sound.intercrap.com/strudel/interleave-recursive.bundle.js');
const ilBlob = await res.blob();
const objURL = (window.URL ? URL : webkitURL).createObjectURL(ilBlob);
const sc = document.createElement('script');
sc.setAttribute('src', objURL);
sc.setAttribute('type', 'text/javascript');
sc.setAttribute('id', 'interleave-recursive');
document.head.appendChild(sc)
let start = new Date();
while (typeof interleaveRecursive === 'undefined') {
  if (new Date() - start > 5000) throw new Error('Couldn\'t load interleaveRecursive');
}

All of this feels klugey and ill-advised, but I had a bee in my bonnet to see if I could use FoxDot style interleaved patterns of pitch and duration in Strudel.

The answer to that is yes, sort of, but it goes against the grain in terms of how cycles work. But it raises some pretty interesting possibilities: https://strudel.cc/?zbR09cmu96Wr)

Strudel Live Code Cheat Sheet

Andy Chase — Wed, 23 Oct 2024 20:00:00 +0000

Strudel Live Code Cheat Sheet

Notes-to-self for strudel.cc

Task	Function	Note
Globally set cycles per second	`setCps(n)`	Default: 1 cycle per second
Globally set cycles per minute	`setCpm(n)`	Default: 60 cycles per minute

A Mellotron sample library for Strudel

Andy Chase — Tue, 15 Oct 2024 20:00:00 +0000

A Mellotron sample library for Strudel

It's Looptober again and I got off to a pretty good start using Strudel for most of my loops, both out of convenience and as a learning exercise.

It wasn't long before I got interested in Strudel's ability to import samples from anywhere on the web¹, and it seemed like a no-brainer to make a library using the leisureland Mellotron samples.

It works! You can use load it in your Strudel pieces by adding this to the top of your REPL:

samples('https://sound.intercrap.com/strudel/mellotron/strudel.json')

This will make a bunch of Mellotron instruments available to the sound() function:

8Choir: 8 Choir
Bassoon: Bassoon
Cello: Cello
CombinedChoir: Combined Choir
GC3Brass: GC3 Brass
ItalianAccordion: Italian Accordion
M300A: Two Violins
M300B: Solo Violin
MixedBrassB: Mixed Brass B
MkIIChurchOrgan: Lowrey Organ
MkIICombinedBrass: MkII Combined Brass
MkIIFlute: MkII Flute
MkIIViolins: MkII Violins
Orchestra: Orchestra
StJohnsOrgan: St John’s Wood Church Organ
StringSection: String Section
TenorAltoSax: Tenor & Alto Sax
TenorSax: Tenor Sax
Trombone: Trombone
TromboneTrumpet: Trombone & Trumpet
Trumpet: Trumpet
Vibes: Vibes
Woodwind2: Woodwind 2

Harmonize Scales with the Python Musthe library

Andy Chase — Mon, 29 Jul 2024 20:00:00 +0000

Harmonize Scales with the Python Musthe library

I'm pleased to say that a new feature I wrote for the Python musthe music theory library has accepted and merged into the code base.

If you're not familiar with Musthe, it's a general-purpose library for exploring scales and chords; the project README gives a good overview of the kinds of things you can do with it.

I added two new methods to the Scale class: harmonize() and harmonize_dict(). Given any scale, these methods will return all of the diatonic chords (That is, chords containing notes from that scale,) plus dominant 7th chords.

Installation

As of July 2024, you'll need to install musthe directly from the git repository to use the latest features, as there has not been a new PyPi release since 2018:

pip install musthe@git+https://github.com/gciruelos/musthe

Usage

For example, to get a dictionary of chords for the E Dorian scale:

from musthe import Note, Scale
from pprint import pprint

scale = Scale(Note('E'), 'dorian')
pprint(scale.harmonize(), indent=2, compact=True)

This will give you:

[ [ Chord(Note('E4'), 'min'), Chord(Note('E4'), 'min7'),
    Chord(Note('E4'), 'sus2'), Chord(Note('E4'), 'sus4'),
    Chord(Note('E4'), 'open5'), Chord(Note('E4'), 'min9')],
  [ Chord(Note('F#4'), 'min'), Chord(Note('F#4'), 'min7'),
    Chord(Note('F#4'), 'sus4'), Chord(Note('F#4'), 'open5')],
  [ Chord(Note('G4'), 'maj'), Chord(Note('G4'), 'dom7'),
    Chord(Note('G4'), 'maj7'), Chord(Note('G4'), 'sus2'),
    Chord(Note('G4'), 'open5'), Chord(Note('G4'), 'dom9'),
    Chord(Note('G4'), 'maj9')],
  [ Chord(Note('A4'), 'maj'), Chord(Note('A4'), 'dom7'),
    Chord(Note('A4'), 'sus2'), Chord(Note('A4'), 'sus4'),
    Chord(Note('A4'), 'open5'), Chord(Note('A4'), 'dom9')],
  [ Chord(Note('B4'), 'min'), Chord(Note('B4'), 'min7'),
    Chord(Note('B4'), 'sus2'), Chord(Note('B4'), 'sus4'),
    Chord(Note('B4'), 'open5'), Chord(Note('B4'), 'min9')],
  [Chord(Note('C#4'), 'dim'), Chord(Note('C#4'), 'm7dim5')],
  [ Chord(Note('D4'), 'maj'), Chord(Note('D4'), 'dom7'),
    Chord(Note('D4'), 'maj7'), Chord(Note('D4'), 'sus2'),
    Chord(Note('D4'), 'sus4'), Chord(Note('D4'), 'open5'),
    Chord(Note('D4'), 'dom9'), Chord(Note('D4'), 'maj9')]]

Or, for a human-friendlier output you can use harmonize_dict() and format the chords as strings:

for note, chords in scale.harmonize_dict().items():
  print(note)
  for c in chords:
    print(f"\t{c}")

Which gives you:

E
        Emin
        Emin7
        Esus2
        Esus4
        Eopen5
        Emin9
F#
        F#min
        F#min7
        F#sus4
        F#open5
G
        Gmaj
        Gdom7
        Gmaj7
        Gsus2
        Gopen5
        Gdom9
        Gmaj9
A
        Amaj
        Adom7
        Asus2
        Asus4
        Aopen5
        Adom9
B
        Bmin
        Bmin7
        Bsus2
        Bsus4
        Bopen5
        Bmin9
C#
        C#dim
        C#m7dim5
D
        Dmaj
        Ddom7
        Dmaj7
        Dsus2
        Dsus4
        Dopen5
        Ddom9
        Dmaj9

If you prefer to omit dominant 7th chords, you can use harmonize(include_dom7=False) and harmonize_dict(include_dom7=False).

A hacked-together Python command-line Audio Player

Andy Chase — Tue, 09 Jul 2024 20:00:00 +0000

A hacked-together Python command-line Audio Player

The other day it occurred to me to see if there were any good terminal-based audio players since the last time I looked.

There weren't, at least not in the goldilocks zone that I have in mind, which is a little more than mplayer and a lot less than cmus. All I want is a terminal command that takes some audio filenames and plays them with a nice TUI and basic start/pause/stop/skip controls.

While poking around today I found the Python audioplayer library, and it didn't take much to get a script working that will:

Load audio files from a directory
Play them in order, using tqdm to show a progress bar as they go.

from audioplayer import AudioPlayer
import os
from time import time
from tqdm import tqdm
ALBUM = './Optiganally Yours/O.Y. In Hi-Fi'
for f in sorted(os.listdir(ALBUM)):
    if f[-4:] == 'flac':
        p = AudioPlayer(f"{ALBUM}/{f}")
        # (There might be a way to make the player load the file without
		#  the play/pause step, but I haven't dug too deeply)
        p.play()
        p.pause()
        dur = round(p._player.duration())
        started_at = time()
        tick = started_at
        p.play()
        pbar.update(1)
        is_playing = True
        with tqdm(total=dur, desc=f.rjust(25, ' ')) as pbar:
            while round(p._player.currentTime()) <= dur and is_playing:
                now = time()
                if now - tick >= 1:
                    pbar.update(1)
                    tick = now
                if tick - started_at >= dur:
                    is_playing = False
        p.stop()
        p.close()
        pbar.close()

I also discovered blessed, which could be used to build an actual interface.

Prerequisites

You'll need gstreamer installed on your system, and the following Python packages:

audioplayer
tqdm

I ran this right from a REPL, but it ought to work as a script.

A Chord Progression Generating Bot for the Fediverse

Andy Chase — Wed, 27 Mar 2024 20:00:00 +0000

A Chord Progression Generating Bot for the Fediverse

My short term obsession for the last couple of weeks has been @progressions, a Python-based bot that:

Generates a random chord progression in a random key
Generates LilyPond markup to display the chords in standard musical notation (along with their names and roman numerals)
Engraves the LilyPond to a PNG file
Applies a random color scheme to it to keep things interesting
Toots it to a Mastodon instance

I have a couple of additional features in mind, and eventually I want to apply things learned to an Arduino device that would function as a songwriting and/or practice tool.

Personal Advent of Code 2023

Andy Chase — Sat, 25 Nov 2023 19:00:00 +0000

Personal Advent of Code 2023

I like Advent of Code in concept, but I've never managed to stick with it more than a couple of days; I don't do well with the "frustrating arbitrary logic puzzles I will never need to deal with IRL unless it's in the context of a crappy tech job interview" aspect of it.

But I still have plenty to learn with Rust and my new related short-term obsession, Rust for the MOS 6502 microprocessor. Giving myself discrete little challenges to chip away at will probably serve me well.

I don't think I'm going to make an entire list ahead of time, though, because that's not how short-term attention span obsession works for me.

My December 1 challenge will be:

Create a Rust/MOS6502 template repository that includes a README with environment setup steps

Using the Eleventy RSS Plugin with `pathPrefix`

Andy Chase — Mon, 20 Nov 2023 19:00:00 +0000

Using the Eleventy RSS Plugin with `pathPrefix`

This site (at the time of this post, anyway) is hosted on a tilde and as such every resource on it has a URI beginning with /~moondog8.

`pathPrefix`

Eleventy provides a config option called pathPrefix for this scenario.

`absoluteUrl`

The Eleventy RSS Plugin provides a filter called absoluteUrl that you can use to prepend your site's domain name to any page links that appear in your RSS feed.

`absoluteUrl` with `pathPrefix`

When trying to get an RSS feed for this site working, I used one of the sample feed templates and all of the permalinks were broken; absoluteUrl has no awareness of pathPrefix, and it took me a minute to figure out how to get them working.

The Solution

In a nutshell: Anywhere in your RSS template that you see a link being passed to the absoluteUrl filter, ie:

{{ permalink | absoluteUrl(metadata.url) }}

{%- set absolutePostUrl = post.url | absoluteUrl(metadata.url) %}

Send it through the url filter^* first:

{%- set absolutePostUrl = post.url | url | absoluteUrl(metadata.url) %}

^*I haven't tried this with the newer HTMLBase element, but if I read the documentation correctly, you should be able to use:

{%- set absolutePostUrl = post.url | htmlBaseUrl | absoluteUrl(metadata.url) %}

Stubble!

Andy Chase — Mon, 13 Nov 2023 19:00:00 +0000

Stubble!

I started fooling around with Eleventy around the same time I started fooling around with Rust, and although typing out a few lines of front matter is not a ton of work in the scheme of things, I did find myself thinking it would be nice to have a tool that would take a title and stub out a new Markdown file for me... so I wrote one in Rust (with help from Rob!)

It's called Stubble and it's already grown a fair bit beyond the above description, but I've been trying to build it in a "works minimally, also provides power user features" frame of mind.

If you run stubble with a single argument:

stubble "My New Post"

It generates a file called YYYY-MM-DD-my-new-post.md in the current directory (where YYYY-MM-DD is the current date).

The file looks like this:

---
title: "My New Post"
date: 2023-11-14
author: "Andy Chase"
uuid: 88d71e51-391d-405e-9ead-50ae6a4ee5b7
---
# My New Post

<!-- Generated by Stubble v0.3.2 -->

It's pretty handy!

You can also add a description, and tags, override various options, and (soon) choose multiple built-in formats (Currently the only other one that's been implemented is a .org stub, but the plumbing is there for as many text-based file types as a person could need.)

Here's the help overview as of version 0.3.2, released earlier today:

Stubble is a command-line tool for quickly generating markdown files for use by static site generators. Given a title, it will generate a date-stamped markdown file with pre-populated YAML front-matter.

Usage: stubble [OPTIONS] <TITLE> [DEST]

Arguments:
  <TITLE>  Title of the post
  [DEST]   Output destination [default: .]

Options:
  -s, --slug <SLUG>                Optional slug to be used for the permalink
  -t, --tag [<TAG>...]             Tag(s) to apply to the post. Separate multiple tags with spaces
  -D, --date <DATE>                Override the post date: YYYY-MM-DD
  -d, --description <DESCRIPTION>  Post description
  -a, --author [<AUTHOR>]          The name of the author
  -f, --format [<FORMAT>]          The output format that should be used to render the stub. [default: md]
  -o, --output <OUTPUT>            Override the default filename
  -e, --editor [<EDITOR>]          Open in <EDITOR>
  -y, --yes                        Automatically answer 'Y' to all prompts (including existing file warnings)
  -h, --help                       Print help (see more with '--help')
  -V, --version                    Print version

There's no real roadmap yet; so far it's mostly been an exercise in getting familiar with Rust.

The only other major feature I have in mind is the ability to bring your own templates (Stubble uses handlebars-rust under the hood) and add your own key/value pairs.

I'm also hoping this project holds my interest long enough to build an actual info/documenation web site for it, and finally learn about getting software into various package management registries.

In the meantime, though, you can install Stubble with cargo if you already have a Rust environment on your machine:

cargo install stubble

You can also visit its Crates.io page, or look at the source code.

Hexadecimal colors and the Rust `palette` Crate

Andy Chase — Sat, 04 Nov 2023 20:00:00 +0000

Hexadecimal colors and the Rust `palette` Crate

My ongoing Rust tinkering found me wanting to fool around with color manipulation; I'd like to write a color exploration/palette generator web API and front end.

This led me to the palette crate, which I'm pretty sure does everything I need and then some, but because I'm still in "only know enough to be dangerous" mode with Rust, it took me a while to figure out how to instantiate an Rgb struct directly from a web-style #abcdef hexadecimal color string.

TL;DR, you can use the FromStr trait:

Code:

use std::str::FromStr;
use palette::{rgb, Srgb};

let my_rgb: rgb::Rgb<Srgb, u8> = rgb::Rgb::from_str("336699").unwrap()

println!("{:?}", my_rgb);

Output:

Rgb { red: 51, green: 102, blue: 153, standard: PhantomData<palette::rgb::rgb::Rgb> }

rgb::Rgb::from_str() supports strings with a leading octothorpe ("#336699"), and it will also take a &String instead of a literal.

Archaeology

Andy Chase — Fri, 03 Nov 2023 20:00:00 +0000

Archaeology

Now that I seem to be gardening again I've decided to start working on pulling in content from various regularly-ish updated web presences I've had going back to ~2000. A lot of it is actually still out there on an ancient web site that I've been meaning to mothball forever.

A couple of years ago I went to the trouble of dumping it into JSON, but that was as far as I got.

Somewhere or other I also have the archive of everything I uploaded to Flickr from 2004 until... 2016ish?

It will be nice if I can massage it all into regular old markdown files with related media all in one place... after almost 30 years on the web, markdown feels like the best long-game format for staying on top of all of my old crap. SSGs come and go, but pretty much all of them operate on the principle of "chew on markdown and turn it into something else," and I like that better than logging into some web admin and hoping it still works.

This is my third attempt at reviving some kind of personal web site in the last year, and each time I have avoided the word "blog" as much as I can, because I've never liked it. At the time the words "blog," "blogger," and "blogging" started to became A Thing circa 2000, I remember it seeming like tech journalists were really trying to make it happen.

People regularly posting dated entries to personal websites was not a new thing, but the combination of 1) the web and home computers having been around long enough to no longer be nerds-only and 2) the emergence of free online services that made it easy to post date-based journaled entries was something new, and I guess "blog" was the term that was quirky and annoying enough to stick.

This was also around the time that people began to get truly obsessed with SEO, and the narrative shifted from "I don't know, just put some funny/cool stuff up on my web hosting account" to "but if you don't update your blog regularly and have a specific focus and pepper your entries with just the right amount of keywords and tags, it will negatively affect your search engine ranking and that's the worst thing that could possibly happen!"

As a relatively green web dev who was trying to get into the game, I bought into that mindset and lost the thread for a long time. Web sites went from an amazing global way to share knowledge and content to increasingly indistinguishable brochures, all twisted by whatever the prevailing SEO wisdom of the month was.

I also went through several cycles of "but if I'm a professional web developer then I should have a slick and polished and carefully curated web site!" but my actual web graphic design skills peaked around the time of the dot com crash and the days when being able to competently construct your own resume/portfolio site were enough to get you an interview, if not a job, are far in the past, so... those never amounted to anything either.

So, fie on blogs. This is just a web site.

Note to Self: OS Keyboard Shortcuts Edition

Andy Chase — Thu, 02 Nov 2023 20:00:00 +0000

Note to Self: OS Keyboard Shortcuts Edition

Environment	Task	Keyboard Shortcut
MacOS
	Emoji picker	`Ctrl + Cmd + Space`
	Show hidden files in Finder	`Cmd + Shift + .`

Note to Self: Emacs Edition

Andy Chase — Thu, 02 Nov 2023 08:11:06 +0000

Note to Self: Emacs Edition

Keybindings and such that I really ought to remember by now

Mode	Task	Command	Note
General
	Make text larger	`C-x C-=`
	Make text smaller	`C-x C--`
	Comment out the current line or region	`comment-dwim` (`M-;`)
	Get help for a function	`C-h f <function name> RET`
	See the current value of a variable	`C-h v <variable name> RET`
	Show all active keybindings for current buffer	`C-h b`
	Close =dired= buffers behind you as you navigate	`(setq dired-kill-when-opening-new-dired-buffer t)`
	Run a shell command and put its output into the current buffer	`C-u M-!`
	Pass the current region to a shell command and replace it with the output	`M-\|`
Working with Buffers
	Save all buffers	`C-x s !`
Moving Around
	Go to start or end of buffer	`M-<` (start), `M->` (end)
Org mode
	Open an agenda view restricted to the current buffer, subtree or region	`C-a <` (Then select an agenda)
	Detangle source code	`org-babel-detangle` (Important: must be run from the tangled source code buffer, not the original org file)
Dired
	Delete marked files	`dired-do-delete` (`D`)
Markdown
	Insert a table	`markdown-insert-table` (`C-c C-s t`)
	Insert a table column	`markdown-table-insert-column` (`C-c S-<right>`)	Row is inserted to the left of point
	Insert a table row	`markdown-table-insert-row` (`C-c S-<down>`)	Row is inserted above point
TRAMP
	Edit a file with `sudo`	`C-x C-f /sudo::/etc/my/protected-file.conf`
	Open a file over SSH	`C-x C-f /ssh:user@example.com:/path/to/remote/file.txt`
Dates
	Formatting dates+times	`format-time-string` (formatting reference)
Customization
	Set a variable in =.dir-locals.el=	`M-x add-dir-local-variable`

Note to Self: When Thunar Hangs on an SFTP gvfs Session and Won't Restart

Andy Chase — Tue, 31 Oct 2023 20:00:00 +0000

Note to Self: When Thunar Hangs on an SFTP gvfs Session and Won't Restart

Environment

Problem

I had a Thunar file manager window connected to a remote server using an ssh://user@hostname/path/to/remote/subdir URL (which uses gvfs under the hood)
The window froze and I eventually got a "taking a long time to respond / do you want to terminate?" sort of message
Terminating from that dialog did close all of my Thunar windows, but Thunar would not relaunch after that.

Solution

A bit of searching led me to a more or less identical issue description here.

TL;DR

There were some stray gvfsd-sftp processes still running. I killed them with:

pkill -f gvfsd-sftp

After that, Thunar opened right back up.

Site Goals

Andy Chase — Mon, 30 Oct 2023 20:00:00 +0000

Goals for this Site

Before I was dragged kicking and screaming into modern JavaScript-based web design, I would often try out whatever web app I was building in Lynx, the text-based web browser that's been around since 1992.

If a web site/web app works in Lynx --by which I mean: makes sense structurally and still provides the functionality intended-- it's doing something right.

Modern frameworks like Vue and React are clever and interesting and even sometimes fun to use, but every once in a while I have an out of body of experience where I really look at the massively complex Rube Goldberg machinery that JavaScript developers have built to shadow the DOM, render custom markup in the browser (and, now, even more absurdly, on the server), bundle code from thousands of JavaScript packages, and ultimately just spit it back out as HTML, and I want to turn off my computer, stand up, and move to a cave.

So, maintaining this site as an old-school, click-a-link-and-refresh-the-browser site is goal number 1.

Accessibility

I need to do better than "make sure to put alt-text on images," it's embarrassing how little experience I have in this area for as long as I've been at this.

Etc.

I've been using Emacs for 20+ years but it wasn't until earlier this year that I made an attempt at actually using it IDE style (vs jumping in to hack on a file or two.) It's slow going, but that's OK.

Concerning Habits

Andy Chase — Sun, 29 Oct 2023 20:00:00 +0000

Concerning Habits

It's been about one year since I started a bullet journal in an effort to keep on top of all-the-things.

I did fairly well for a couple of months, then hit a point where I found myself migrating the same unfinished tasks too many weeks in a row and spiraled into futility mode for a while.

When I came out of it, I re-discovered Org Mode for the umpteenth time, and this time I also discovered habit mode, which is absolutely brilliant for all of the trivial "change the HEPA filter on the vacuum cleaner in n months" crap that has a tendency to slip days, weeks, months, even years past due. Org Mode doesn't provide any magic to make the "hey this non-trivial thing that you need to do still hasn't been done" problem go away, but it does let you punt them into the future for a while.

It's mildly upsetting to realize I've already been at this a year. On the one hand I don't feel anywhere near being on top of all-the-things... on the other, little things definitely pile up less than they used to, so I'll call that a win.

That one time I worked on Star Trek: Deep Space Nine

Andy Chase — Tue, 17 Sep 2019 20:00:00 +0000

That one time I worked on Star Trek: Deep Space Nine

In late 1996/early 1997 I found myself working at a practical special effects shop in North Hollywood, California, doing mostly menial tasks on various props and costumes for this and that, but also learning the trade and demonstrating enough of a knack for it that I was put on some builds. By far the most noteworthy one I worked on was this target robot suit for Star Trek: Deep Space Nine Season 5, episode 18, Business as Usual.

I worked under the supervision of the designer and from what I remember, fabricated most of the base armor pieces and did a fair amount of detail work as well, with the designer putting on final touches.

I missed the episode when it originally aired and finally saw it all these years later, now that I'm finally watching the series from start to end. Like so many effects projects that you spend weeks of your life working on, it is visible for about one second in the final episode:

Workbench

Exporting Org Mode to Markdown with Yaml Frontmatter

Exporting Org Mode to Markdown with Yaml Frontmatter

Problems

Static site generators rely on YAML frontmatter for document metadata

Various org-to-markdown exporters have lousy support for frontmatter

A Lazy Solution Hack

Formatting a Cheap Generic MicroSD Card For the Digitech Trio+

Formatting a Cheap Generic MicroSD Card For the Digitech Trio+

Checking the format of a known good card

Checking the format of the new card

Reformatting the new card

Directionally Aware Collision Detection in Pico-8

Directionally Aware Collision Detection in Pico-8

Basic Collision Detection

Determining Directionality

Note to Self: Networking Edition

Note to Self: Networking Edition

Get a List of Every IP on a LAN[1]

Using ping

Using nmap

Note to Self: Lilypond Edition

Note to Self: Lilypond Edition

Vertically Align and Horizontally Space Markup Above the Staff

Note to Self: ImageMagick Edition

Note to Self: ImageMagick Edition

Generate a Limited Palette From a Source Image

Apply a Limited Color Palette to an Image

Harmonize: an app for exploring scales and chords

Harmonize: an app for exploring scales and chords

Note to Self: Docker Edition

Note to Self: Docker Edition

Running `yt-dlp` with Cookies

Running yt-dlp with Cookies

Looptober 2025

Looptober 2025

Found an Old Friend

Found an Old Friend

A Bash Alias For Viewing READMEs From the Command Line

A Bash Alias For Viewing READMEs From the Command Line

Prerequisites

The Alias

Chord Navigator, Part 1

Chord Navigator, Part 1

Tangling Org Mode Properties Into Source Code Blocks

Tangling Org Mode Properties Into Source Code Blocks

Ciglet: Figlet Comment Blocks

Ciglet: Figlet Comment Blocks

How to get a node.js `Dirent` object directly from a path

How to get a node.js Dirent object directly from a path

Stupid Strudel Tricks

Stupid Strudel Tricks

Strudel Live Code Cheat Sheet

Strudel Live Code Cheat Sheet

A Mellotron sample library for Strudel

A Mellotron sample library for Strudel

Hear it in Action

Harmonize Scales with the Python Musthe library

Harmonize Scales with the Python Musthe library

Installation

Usage

A hacked-together Python command-line Audio Player

A hacked-together Python command-line Audio Player

Prerequisites

A Chord Progression Generating Bot for the Fediverse

A Chord Progression Generating Bot for the Fediverse

Personal Advent of Code 2023

Personal Advent of Code 2023

Using the Eleventy RSS Plugin with `pathPrefix`

Using the Eleventy RSS Plugin with `pathPrefix`

pathPrefix

absoluteUrl

absoluteUrl with pathPrefix

The Solution

Stubble!

Stubble!

Hexadecimal colors and the Rust `palette` Crate

Hexadecimal colors and the Rust palette Crate

Archaeology

Archaeology

Get a List of Every IP on a LAN^[1]

Using `ping`

Using `nmap`

Running `yt-dlp` with Cookies

How to get a node.js `Dirent` object directly from a path

`pathPrefix`

`absoluteUrl`

`absoluteUrl` with `pathPrefix`

Hexadecimal colors and the Rust `palette` Crate