This post has been hanging out in my drafts folder a long time. I started writing these work notes in second person back when I thought this would be a straightforward project, maybe I’d finish and have a tutorial that highlighted the one or two rough spots. That didn’t work out, but I’m not putting in even more time to rewrite it.

Install

Despite spending a few years of my career as a Python developer, I’ve never been able to keep tools written in Python working for more than a few months without some update blowing it up (let alone a dev setup). I’ve tried many of the various packaging tools over the decades, no real change in MTBF. I’ve been using a new installer called uv that does keep them working. To install with aome very useful optional dependencies: uv tool install beets --with bs4 --with librosa --with pylast --with pyacoustid --with resampy --with soundfile

Run: beet --help.

It will load your plugins and they’ll complain about most missing dependencies. If you see an exception, puzzle out which python module it wants (eg acoustid is in pyacoustid), run uv tool uninstall beets, and rerun the uv tool install adding the missing library to a --with.

Install your distro’s packages for ffmpeg and oggz (may be named liboggz) to check for corrupt files with the badfiles plugin.

First run: auto-tagging

Using beets is broken up into 3+ runs of the software to shake out issues with the config or your library before making any edits to music files. This first run is about collecting info on your library into the beets database (~/.config/beets/library.db).

Here’s my .config/beets/config.yaml and the config docs.

The important parts to highlight are:

• The paths uses filenames I’ve used for ages for compilations and single tracks, you probably didn’t organize your music like this.
• Plugins are configured to write into the music files and will do so on this first run. Surprise! So you get to review each plugin’s config individually.
• The import section has copy, move, and write all set to false to avoid rewriting tags on the first pass. This is to work around a UX problem (described below), but also to give time to build confidence in how beets works.

Optional: review Metadata Source Plugins to configure searching more music info databases.

Run: beet import --autotag --quiet --incremental-skip-later ~/music

This will take hours and print a lot of debugging info. My ~17k tracks took a little over 5 hours, roughly 1 second per track.

--quiet doesn’t quiet output, it skips the process of making manual decisions. That’ll be the second run, explained next.

On the first run, it will incorrectly print Resuming interrupted import of ~/music. This is harmless.

If there are errors, rm ~/.config/beets/import.log and ~/.config/beets/library.db to start over from scratch. But if it crashes or you have to ctrl-c it to finish later, just re-run the same command to resume where you left off.

(Speaking of which, I ran into a crash bug with fromfilename; I re-ran with -v and an added print to the plugin to try to get the filename, but it ran clean. Weird.)

Go looking for problems

Run beet bad | grep "WARNING" | grep -v "No supported tags in the file" at some point to find corrupt and truncated tracks.

The first grep strips out redundant “checker found N errors or warning” messages; the second strips out a warning for untagged files because that’s fine, we haven’t gotten to the tagging run yet. Don’t enable the badfiles check_on_import config because it ignores --quiet.

Good luck, hopefully you don’t have too many damaged files. Around 4% of my mp3s had minor issues, none unplayable.

There’s a tool called mp3val that can repair mp3s. Putting it together: beet bad | grep "WARNING" | grep -v "No supported tags in the file" | cut -d'"' -f 2 | grep -i .mp3$ | xargs -d '\n' mp3val -t -nb -f

I had a handful of tracks in other formats (flac, m4a, mp4, ogg) with minor errors, but I was able to quickly convert them: find . -name "*.m4a" -exec bash -c 'for file; do output="${file%.mp4}.mp3"; ffmpeg -i "$file" -vn -c:a libmp3lame -q:a 2 "$output"; done' _ {} \;

Second run: manual tagging

The primary value of beets is “auto-tagger”, which mostly automatically identifies and tags files. When it can’t make a confident decision it asks you, so you use the “auto-tagger” to make manual tagging decisions. The Using the Auto-Tagger doc describes the process.

I split manual tagging out into a separate run because of its UI problems. When the auto-tagger is waiting on a decision from you, it continues scanning files in the background. On your first run there will be a lot of noisy messages (often from plugins), so your decision prompts will be randomly scrolling up and off the screen while you’re trying to read them. There’s no way to pause the background work or repeat the prompt.

Extract a clean list of what was skipped:

Run: grep "^skip " ~/.config/beets/import.log | sed 's/^skip //' | sort -u > /tmp/skipped.txt

Then work through them individually with beet import -I ~/music/whoever or all with cat /tmp/skipped.txt | xargs -d '\n' beet import -I. The -I ignores if you skipped a directory previously. Inconveniently, beets says “skipped” to mean both “this is already imported, nothing to do” and “you skipped this and didn’t pass -I”.

Tagging is a slow process with very frustrating UI. I’m not going to make myself mad writing out all the details because nobody would read it. (This situation is why I’ve given away a dozen copies of Badass by Kathy Sierra and occasionally been driven to impart its wisdom via percussive osmosis.)

Between albums beets will stall for seconds or minutes as it waits on API rate limits. Usually it will continue to print out-of-context and non-actionable debugging messages to the terminal. While it’s a little nice to know beets hasn’t frozen, when you come back to the terminal you’ll may have no idea what prompt scrolled off the screen. The only safe thing to type is S to Skip and then hope to find the album on a later run.

If you’re curious how far behind your editing beet has fallen, you can keep sudo strace -p $(pgrep -f beet) -e trace=openat -f 2>&1 | grep -oP '"\K[^"]+\.mp3' | awk '!seen[$0]++' running in another terminal.

Honestly, I couldn’t finish this run. It’s painfully slow, it often misses metadata clues in the filename so I have to manually search and suffer the delay again. And there’s no utility, no incremental progress unless I wanted to take off the safeties and start writing to my collection. So I backed up the database and threw Claude at it, told it to leave existing tags on a couple albums I had tagged deliberately, to apply fixes that seemed real likely, and to make a list for human review of anything seemed genuinely weird. It churned, I spent maybe an hour reviewing the esoterica, done. The point of the project was to take the error rate down from 60%; if an LLM took it down to 1% that’s a lot better than an Sisyphean slog where a human fails to take it down to 0%.

Third run: reviewing and applying tags

Now that the music metadata is correct in the beets database, you can use beet list and beet stats to query the your beets database.

For example beet list -f '"$path","$album","$year","$track","$artist","$title","$genre"' > compare.csv to generate spreadsheet of your key metadata.

The big value is writing this metadata into the mp3s themselves so that every music player can read them. To see all potential changes, run: beet write --pretend, probably piping its infinite output into a csv or some grep pipeline to cut it down to meaningful decisions.

If everything looks good, run it again without --pretend.

N runs: expansion and maintenance

Run beet import ~/music when you add new music.

Run beet remove -f to tell beet to forget about files that no longer exist.

Run beet duplicates to find duplicated tracks.

Run uv tool upgrade beets to get new versions without losing hours to python packaging stack traces.

Use mbsync to pull in updated metadata. Run beet mbsync -p to preview changes; run again without -p when happy.

A friend of mine is getting a mortgage for the first time. American mortgages are “amortized”, which is a suspicious concept.

In short, you pay the same amount every month but your payments are split between “principal” that pays back what you borrowed and “interest” that is the bank’s revenue. The split changes over time: your early payments are mostly interest, and over the life of the loan that split dwindles until your money goes entirely to principal.

This feels pretty weird, like maybe you’re getting ripped off at the beginning. Your money isn’t effectively paying off the loan right from the start? If you sell the house 10 years into a 30 year mortgage, shouldn’t you have a third of the equity? Now, there are reasons that amortization benefits both you and the bank, but I’m not going down that enticing rabbithole because I want to talk about something even more thrilling: charts.

If you try to read an intro to amortization you will see a lot of tedious tables ⊕Finance jargon calls a table a "schedule" if it has dates in the future. and, in the nicer ones, a useless chart like this:

I appreciate an accurate but uninformative explanation as much as the next reader of man pages, but these charts are especially useless because they’re drawn from the bank’s perspective. The loan is their product, so they’re thinking about it top-down, the total values over the loan’s lifetime. ⊕The chart is also redundant. The balance is the inverse of the principal. Your eye is drawn to where the curves intersect, but those points don’t indicate anything meaningful. You think bottom-up, from the monthly payment that will become a very important feature in your life.

I was thinking about how to explain amortization better and I remembered how much I love fillable progress trackers and burndown charts. I once had a job at company with a typical four year equity grant: one year cliff, then quarterly vesting. About a year and a half in, I wanted a vivid reminder of each day’s value. On a little whiteboard I wrote how many days left until the next vest, and empty boxes for the each vesting.

Each morning I’d count down one more day, and once a quarter I filled in a box to mark one more grant. It helped.

I rolled these two topics around in my head and came up with a visual presentation to combine them. I sketched them out in Claude Code using Opus 4.8, and got this hybrid where the years run down the page and each box is sized to the principal you’re paying off that month.

The void between the principal payments and the right edge of the chart is the part of your payment that goes to interest. If you lay your head on your right shoulder you’ll see the boxes form the same shape as the “principal” line on the useless chart above.

It’s online if you’d like to play.

The number down the right column is the remaining principal to pay off; $300k in this example. I considered a running total of equity in this column, but it felt misleading when the final property value will be different than the original sale price. Percentage could work.

Interactive visualizations of how dynamic systems respond to varying input (“video games”) can be pretty instructive. This one sufficed for for talking through the parts that my friend was struggling with.

Continuing to tinker in CC, I threw on on some display options. Maybe the most useful is the ‘principal + interest’ mode that visualizes that your full payment with a reducing percent shaded to indicate the interest payments. (Though I’m not happy with how that forms vertical shapes which falsely imply each column of months has its own change over the years.)

The weakest pedagogy of this visualization is that it doesn’t really beat you over the head with how small changes to the interest rate have very large changes to the overall cost of the loan (that is, the total interest payments). You have to play with the interest rate a bit to get it. Maybe it’s worth showing the sum of the interest payments, or allow entering two interest rates.

Similarly, there’s a missed opportunity to teach the value of making additional principal payments. Entering one-off or recurring additional payments would move the right edge of the principal boxes to the right for that year and every following year. ⊕An inverse of the rocket equation, to give another vivid example. Maybe it would make visual sense to indent the left side of all future years to show the effect of prepayment.

If you’d like to tinker with these or other ideas, or use it in any way, knock yourself out. Between the CRS report and Thaler v. Perlmutter it seems that vibecoded software is in the public domain.

So I used graphviz to knock out a state diagram showing the number of clicks to switch between modes:

This is missing that the ‘Regular’ mode will start in the mode that it last spent 3 minutes in. I couldn’t think of a way to represent that graphically that would be clear at a glance, so if I had to use words to explain the graphic I might as well just have written out that previous sentence.

While this diagram may be useful in the unlikely case you buy the exact same flashlight, my own familiarity came more from the effortful study of creating the diagram than looking at the diagram. So I’m really sharing this as an example of a useful study technique.

Here’s the source, if you’d like to use it as a starting point for your own diagrams:

digraph FlashlightStateMachine {
    rankdir=TB;
    node [shape=rectangle, style=rounded];

    // Main states
    locked [label="Locked Off\n(blinks twice)" style="rounded,dashed"];
    unlocked [label="Unlocked Off\n(blinks three times)" style="rounded,dashed"];
    momentary [label="Momentary On", style="rounded,bold"];
    regular [label="Regular On", style="rounded,bold"];
    sidelight [label="Sidelight On", style="rounded,bold"];

    // Bidirectional edge between locked and unlocked
    locked -> unlocked [label=" 5", dir="both"];

    // Momentary transitions
    unlocked -> momentary [xlabel="hold", dir=both];

    // Regular on transitions
    unlocked -> regular [label="2"];
    regular -> unlocked [label=" long"];

    // Sidelight transitions
    unlocked -> sidelight [label="3"];
    regular -> sidelight [label="3"];
    sidelight -> unlocked [label=" long"];

    // Subgraph for Regular On brightness levels
    subgraph cluster_regular {
        label="Regular Modes";
        style=dashed;

        low [label="Low"];
        med [label="Medium"];
        high [label="High"];
        moon [label="Moon"];

        low -> med;
        med -> high;
        high -> moon;
        moon -> low;
    }

    // Subgraph for Sidelight modes
    subgraph cluster_sidelight {
        label="Sidelight Modes";
        style=dashed;

        white_low [label="White Low"];
        white_high [label="White High"];
        red [label="Red"];
        red_flash [label="Red Flash"];

        white_low -> white_high;
        white_high -> red;
        red -> red_flash;
        red_flash -> white_low;
    }

    // Connect main states to substates
    regular -> low [style=dotted, arrowhead=none];
    sidelight -> white_low [style=dotted, arrowhead=none];

    // Layout
    {rank = same; locked; unlocked;}
    {rank = same; momentary; regular; sidelight;}
}

https://github.com/pushcx/typeid-lua

TypeID is a nice standard for creating unique id tokens with a Stripe-like ⊕An aside to Stripe from an Xtripe: Please write a eng blog post about the features and history of tokens. It would be pillar content that would be enormously popular for meaningfully advancing the state of the art to a new standard (Not the post about using them.) hungarian notation:

TypeIDs are a modern, type-safe extension of UUIDv7. Inspired by a similar use of prefixes in Stripe’s APIs.

TypeIDs are canonically encoded as lowercase strings consisting of three parts:

1. A type prefix (at most 63 characters in all lowercase snake_case ASCII [a-z_]).
2. An underscore ‘_’ separator
3. A 128-bit UUIDv7 encoded as a 26-character string using a modified base32 encoding.

Here’s an example of a TypeID of type user:

user_2x4y6z8a0b1c2d3e4f5g6h7j8k
└──┘ └────────────────────────┘
type    uuid suffix (base32)

A formal specification defines the encoding in more detail.

Cleverly, the spec comes with a suite of labeled test cases of valid and invalid examples. I wish more specs did this!

I’m happy with the functionality my library offers, and there was the familiar delight of making things the first time I round-tripped a TypeID.

TypeID = require("typeid")
-- or in dev: TypeID = require("./typeid")

t = TypeID.generate("comment")
-- t = {
--   prefix = "comment",
--   suffix = "01jvbhbbdje07rnyqkvstpvcge"
-- }

-- TypeID tables implement __tostring
print(t) -- "comment_01jvbhbbdje07rnyqkvstpvcge"

-- You can extract a standard UUID string
t:uuid() -- "0196d715-adb2-700f-8afa-f3de756db20e"

-- and round trip that back into a TypeID
TypeID.from_uuid_string("comment", "0196d715-adb2-700f-8afa-f3de756db20e")

-- parse and validate a TypeID from a string
TypeID.parse("comment_01jvbhbbdje07rnyqkvstpvcge")

-- finally, you can generate with a unix timestamp in ms:
TypeID.generate("comment", 1) -- "comment_0000000001e8avt0nh7a68v2jc"

This was a fun practice project for me. I’ve used Lua more and more over the last few years in video game scripts and my window manager, and while 1-based array indexes will always feel odd, I think there’s a lot of potential in the language.

I experimented with style while implementing, and a lot of what I’m taking away from it is idioms I’m ignorant of. The TypeID is more OO style and returns an object with a method; the Base32 and UUID7 modules work on primitives. After implementing, I guess users would probably prefer getting a primitive back, as there doesn’t seem to be an idiomatic way to type-check. A module can export a trusted constructor, but without types there’s no way to use that to prevent instantiating invalid objects; everything is a table anyways. Coming from Ruby and ActiveRecord it’s frustrating to have most of a solution to the pervasive problem of passing around invalid objects but not be able to complete it.

I guess have to read popular libraries to get a feel for style. I don’t really know what level to aim at between “data-hiding high-level interface” and “yolo, all primitives and seams showing for perf”. Maybe it’s different inside and outside of games.

Along those lines, I ported Base32 from the official TypeID Golang implementation and then wrote UUID7 in bytes to match it. But all that intermediate bit twiddling could be simplified by generating a UUID7 directly into the Base32 encoding if I wanted to spend a lot more time on this.

Maybe I’m looking under the wrong name, but it seems odd there isn’t a bitfield type I could use, given Lua’s popularity in games. Some searching turned up a library but the absence of multi-bit operations seems inconvenient. Which points to:

-- typeid.lua
uuid = function(self)
  return UUID7.to_string(Base32.decode(self.suffix))
end

There’s a code smell in TypeID: the nested conversions in the metatable uuid function suggest the internal representation of suffix is wrong. The syntactic distinction between .field and :method() means duplicating the data into two fields, exposing the internal representation by it being a field and the other a method, or getting away from what seems like common struct-y style and making both into methods. I’ve really grown to like the way Ruby’s optional parenthesis blur the line on fields and methods.

I wrote this library because I’d like to add a TypeID request identifier as a trace ID that nginx would generate and log, and pass along through Rails logs to MariaDB logs. It’s overkill for Lobsters but once a year I really wanted the ability to correlate logs like that. While the ROI may not really justify the time, it was a uniquely well-scoped small practice project.

Writing in Lua and adding the Lua module support to nginx seemed an easier path than writing in C and adding that compilation step to the deploy pipeline. Ultimately though, I’m not going to write that wrapper module.

On a parallel track, our ansible setup has slowly been succumbing to bit rot and my inexpert maintenance. I learned that Hatchbox could fill the same role and paying a couple bucks a month means it’s maintained by an expert professional. So 355e3b are going to move our hosting over soon, and it uses Caddy instead of nginx, so I guess I’ll wrap the official TypeID Golang implementation in a Caddy module instead. Still, it’s rewarding to contribute to TypeID’s list of supported languages.

I put together 15 variants, with inspiration and copying from here, here, and especially here. These aren’t intended to be long-term playable games with polished rules, just wacky variations for a silly night.

I wrote these out on a stack of index cards. We played each variant for one round of dealing, so 6-7 hands of each. I only revealed one variant before we played:

I put the variants in order to escalate complexity, to set up the Fuck Yeah/Fuck No joke, to provide a breather after the complexity of Auction House, and to end with Double Trouble because it was the idea that kicked all this off.

1. Bonus Start with 1 extra hole card, face up.
2. Roswell Start with 2 hole cards down and 1 up. After river betting: draw an extra hole card, do an extra betting round.
3. Trashy Start with 3 hole cards. After each betting round: players select 1 hole card and simultaneously pass it to the player on their left.
4. Stairstep Five betting rounds, each round you get 1 hole card and 1 community card.
5. Fuck Yeah After each betting round: draw 1 hole card, then discard 1.
6. Fuck No After each betting round: discard 1 hole card, then draw 1.
7. My Ship Will Come In After the turn betting: reveal 2 cards. Those ranks are wild.
8. Regret Start with 5 hole cards. After the flop, turn, and river betting: discard 1 hole card face up near you.
9. Dead Man’s Chest All folded cards go to the chest, down. If the hand ends early, nothing special happens. After river betting, reveal the chest. If the dead hand wins, the pot rolls over.
10. Swapsies At start, turn up a 5 card sideboard. After each betting round, each player may swap 1 hole card with a sideboard card. Keep it face up.
11. Auction House Deal 3 boards. Before each betting round is bidding. Going around once, each active player may bid chips to any 1 board. The board with the most chips is the real one. All bid chips go to the pot.
12. Death on the Nile After river betting: roll a die. Count from the first turn card to discard and replace 1 board card. (Ignore 6, nothing changes.)
13. Haggle Any 2 players, even folded, may agree to a table stakes price or for free, swap 1 hole card, seen or unseen.
14. River of Blood If the final community card is black, bet and end normally. If it’s red, bet and then repeat until you get a black card.
15. Double Trouble Shuffle together 2 full decks, include the 4 jokers as wilds. A pair/trip/quad with a suited pair outranks one without.

Except where noted otherwise, it’s Texas Hold ‘Em rules, hole cards are face down, and actions are limited to the players who haven’t folded.

Mostly I got it because the only movie theater near me is badly managed, but a new apartment’s layout means that if I’m playing games at my desk I can’t talk to my spouse sitting in the front room.

Privacy goal

I care about personal privacy. Basically every TV manufacturer IDs what you’re watching and sells that to advertisers, who can correlate it to you personally because the TV will have the same IP as your web browsing. Creepy shit.

People occasionally suggest buying “commercial panels” but the ones I found were more expensive, lower-quality, and had weird limitations. The solution is to never connect a TV to the internet. ⊕There’s a persistent conspiracy theory that TVs connect to open wifi. This would be very easy to test but I couldn’t find anyone who claimed to have observed it. Luckily TV surveillance is so inefficient about bandwidth that manufacturers can’t afford to put cellular modems in like car manufacturers.

So what are the options for an external device?

• All the popular open source media servers have clunky UI or were unreliable; mostly both. ⊕This HN thread on Jellyfin hits all of the issues I had with the open source options and also hits all of the “you’re doing it wrong” nitpicking I was not interested in participating in.
• Amazon Fire and Roku are invasive and janky.
• The Google Chromecast was made by Google, and so will be the Google TV Streamer.
• The NVIDIA Shield is not bad.
• The Apple TV 4k is good and has a good ecosystem.

OK!

Choosing a TV model

My last TV was a 15” CRT with a failing vertical hold that took a couple minutes to warm up before the picture would stop rolling. A 4k OLED is a stunning upgrade. I’ve been rewatching all my favorite movies because they look so good.

I don’t have an opinion on manufacturer besides never buying Samsung because of low reliability and poor UX.

Use Rtings to find a good current model. Use their size to distance calculator to pick a size for your room.

Apple TV setup

Mount the Apple TV 4k to the back of the TV with velcro tape. Ethernet is almost mandatory; more on this below.

Conveniently, you can use the terrible remote that comes with your TV to turn off motion smoothing and then put it in a drawer to never use. The Apple TV remote is nice, though once I had to reset it when it forgot how to control the TV volume. There’s a virtual remote that is nice for typing searches but otherwise is a peculiar demonstration that directly translating a physical device to a touchscreen feels clunky.

Settings:

• General
  • Restrictions: This is the one missing stair on Apple TV. It has the parental controls you’d expect except you can’t lock the Settings app, so curious kids can change every setting that isn’t about watching a TV show that might have a curse word in it. Whyyyyyyyyy.
  • Siri: off. It doesn’t run on-device.
• Users and Accounts -> Default User
  • Shared with You: off, distracting.
  • Require password for purchases and free downloads. You can auth with an iOS device, which is clever.
• Video and Audio
  • Format: 4k Dolby Vision
  • Match Content: Range & Frame Rate
  • Check HDMI Connection: run after setting the previous
  • Audio: has several accessibility settings, no idea why they’re here instead
• Notifications -> Search, TV: off
• AirPlay and HomeKit: weird that nobody’s gone after them for antitrust about it, but there’s the usual Apple practice of having a wonderful experience for their hardware like AirPods and meh for competitors.
  • Conference Room Display: on, so guests can show things from their phones
  • Require a PIN for AirPlay: on, unless you live somewhere rural
• Remotes and Devices -> Bluetooth: Apple doesn’t make a video game controller so they’re clunky, but controllers that claim to work on Apple TV/iPad/iPhone work fine, with only the usual Bluetooth pain switching between them between multiple devices.
• Accessibility: There is so much good stuff in here, it’s an incredible amount of thoughtful design.
  • Physical and Motor -> Tap to Navigate: off. Guests and kids struggle with the too-clever touchpad on the remote.

Home Screen:

Apple would really like you to subscribe to their things, so there’s a bunch of shovelware you can’t delete like Music, TV, Arcade, etc. You can at least make a folder named “Shovelware” and move it to be the last thing on the home screen. You can’t set Restrictions to keep curious kids out of these, either.

Apps

Tailscale, on the off chance you don’t already use it for your home network. You don’t have to expose your NAS to the internet. The TV app can act as an exit node, which is convenient for dealing with bank “security” that panics if you log in from a coffeeshop. Beyond TV setup, Tailscale continually impresses me with its features, reliability, and polish. It has solved a ton of hassles that have come with having multiple devices and working remotely.

Infuse for playing any kind of media files from most any storage. Excellent UI with automatic metadata download, ⊕Subtitles are only OK. Infuse pulls from OpenSubtitles but could do a much better job of sorting them based on frame rate, resolution, and keywords in the video filename. The UI for styling subtitles lacks a live preview, and the process of adjusting a delay is downright bad. overall much better experience than the various streaming services. Calmer, too, it’s trivial to turn off “Watch Next” suggestions and autoplay of the next episode.

We made a category for “Watch Together” and then a category each for a personal queue.

If Apple didn’t limit apps ability to cache so strictly, Infuse could start playback in 0.1s instead of 2s. But I have to assume most apps would be terrible at filling and pruning their caches, so I guess it’s fair.

SpeedTest for diagnosing network issues.

Steam Link for playing games from your desktop. ⊕UFO 50 is an incredible love letter to the weirdness of the NES/Genesis era with a few modern genres reimagined. If you played back then, don’t read or watch anything about it, just go get the buddy whose basement couch you used to play on and fire this up. It’s really a general purpose remote desktop tool, you can “Add a Non-Steam Game to My Library” to run anything. I’ve used it to run calibre and YNAB from my iPad. One bug/limitation: many games get letterboxed if the aspect ratio of your monitor doesn’t match the TV. I wrote a small shell script and added it three times for switching ratios to match the device I’m using.

8BitDo makes the best controllers.

While the latency is low enough for action games, it won’t be low enough for competitive shooters, fighting games, or precision platformers. The Apple TV doesn’t have ports for USB and the max cable length is only 2 meters anyways. If you don’t run ethernet to the Apple TV, you’ll get an annoyingly disruptive lag spike when your neighbor turns on their crappy microwave.

I’m surprised to say it, but it’s much more reliable to play games from a Linux desktop than Windows. Windows is swarming with intrusive upsell ads and will randomly reboot, so I found myself having to walk over to the desktop fairly often to unbreak it. Valve has put a ton of work into the Steam Deck Compatibility program and Proton so almost every game I play just works. It’s worth noting I get motion sick from 3d first-person and over-the-shoulder games and those are the AAA blockbusters, so I wouldn’t know if those run worse. ⊕A comment on Lobsters reports Linux is bad at HDR. I’ve never played an HDR game and this falls directly in this blind spot.

RetroArch has an Apple TV app, but tvOS is still trapped in the old iPhone misdesign that users can’t be trusted with files. Loading games or retrieving savegames is a chore. It’s acceptable if you only play on the TV but if you want to carry a game between platforms you’ll have to play via Steam Link. ⊕At least on iPhone/iPad you can use the Möbius Sync app for Syncthing to share your RetroArch ROMs and saves. Use an Ignore Pattern for retroarch.cfg to keep configs separate.

There’s some good settings in this article once you scroll past the affiliate ads.

Syncthing

One small caveat with Tailscale and Syncthing: many packages bind its web interface to the local network interface so it won’t be visible across your intranet. This is annoying for headless devices. Find Syncthing’s config.xml and change the <address> to 0.0.0.0 or, better, the machine’s Tailscale IP (100.x.x.x).

<gui enabled="true" tls="true" debugging="false" sendBasicAuthPrompt="false">
  <address>0.0.0.0:8384</address>
  <user>...</user>
  <password>...</password>
  <apikey>...</apikey>
  <theme>default</theme>
</gui>

Controllers are a cake with too many layers

This is a button on my controller:

Then I can rebind it in the firmware:

Then I can rebind it in the Apple TV Settings:

Then I can rebind it in Steam Link:

Then I can rebind it in Linux:

Then I can rebind it in Steam:

Then I can rebind it in a game (here, RetroArch):

Figuring out which layer misconfigs a button is terrible, and it’s just sloppy that none of them know what the controller looks like or how its buttons are labeled.

Valve, you are the only company with market position to drag manufacturers, OS developers, and game developers into the same room to sort this out. I know several of them take Not Invented Here to the extreme, but it would be great if you would abuse your monopoly power for my convenience by dragging them kicking and screaming into pleasant interoperability. ⊕And while you’re at it, bring back the Steam Controller.

If you still have one in a drawer, dear reader, here’s my notes on flashing the latest firmware. Please and thank you.

On November 19, Google announced the Google App for iOS is injecting unlabeled ads into pages. They look like the author created them, as seen in Google’s own screenshot:

Google claims they are injecting ads live now, so I’d like to quickly turnaround a js snippet that sites can use to detect the tampering. I’m strongly reminded of how a motivation for the big lift to HTTPS was slimy ISPs injecting ads into pages.

This system is nearly identical to Microsoft Smart Tags, a 2001 Internet Explorer feature that injected links to Microsoft sites into pages, but without the ability for site owners to disable them with a meta tag. (Recognized by esprehn.)

It’s also similar to Google AutoLink, a 2005 Google Toolbar feature a user could click to inject links into pages.

Google has published no information on how it targets the ads. It may target sites based on Googlebot crawls or may send the url or text of pages that require a login to Google. (Thanks @tasket@infosec.exchange.)

Initial reporting by SERoundtable and 9to5google.

Do you have the iOS Google App installed? Can you find an inserted ad that looks and acts like the screenshot above?

If you have the app and own a site, please check your site. Maybe start with high-ad-value terms like tourist destinations, insurance, loans, attorneys/lawyers, donations, hosting, trading, consumer electronics, or rehab. I would especially appreciate hearing from you so we could iterate on a couple possibilities for detecting this via the DOM.

(I found the victim in their screenshot and have collected 3 negative reports from people unable to reproduce the ad, so it may have been a one-off demo for the announcement.)

“This isn’t ads”

Oddly, a common response has been that the world’s largest advertising company adding links to keywords directed at their own sites isn’t advertising. Sometimes with the caveat that it’s because they’re currently only house ads and not yet for sale to third parties.

A bit of useful history might be Google’s own press release, “Why we sell advertising, not search results”. This was written when AdWords were placed to the side of search results with a blue background to be unambiguously ads. Despite saying that results wouldn’t be for sale, Google slowly iterated the design to make the ads nearly indistinguishable from results.

Today, these injected links start nearly indistinguishable from the author’s own links, with no “Ad” label or icon, and only a faint pastel background similar to the 2010 AdWords treatment. Like AdWords, every experiment Google runs on engagement will show “improvement” as the ads become harder to distinguish,

If you found that an advertising company was adding links to your site without your knowledge or consent, would you consider it a useful service?

Do you think it acceptable that, to disable the injected links, you have to agree to the ad company’s continually-updated terms of service and ask to individually opt-out each of your sites?

Ongoing

There may be more on Bluesky or Mastodon where I’ve tried to find help.

Here’s the first rough draft of a js snippet that a site owner who sees an ad could add to a page to see some more info. It needs text from the link inserted. There’s some assumptions noted for how the injection might appear in the DOM.

(function() {
  const logDiv = document.createElement('div');
  div.style.cssText = 'position: fixed; top: 0; left: 0; right: 0;' +
                      'background: #fee; color: #000; font-family: monospace; ' +
                      'z-index: 999; padding: 10px; max-height: 50vh; overflow: auto;';
  document.body.prepend(div);

  function log(msg) {
    const entry = document.createElement('div');
    entry.textContent = msg;
    logDiv.appendChild(entry);
  }

  try {
    /* edit 'castle' to include the text of an ad link */
    const text = 'osaka castle';

    /* if it's not an 'a', try 'span' and then 'div' */
    for (const ad of document.querySelectorAll('a');) {
      if (a.textContent.toLowerCase().includes(text)) {
        log(ad.outerHTML);
      }
    }
  } catch(e) {
    if (logDiv) {
      log(`Error: ${e.message}`);
    }
  }
})();

Hey folks,

When this post is two hours old, and indefinitely twice a week, I’m going to stream Lobsters office hours and development on Twitch. The channel is here and more info + an archive is on my blog. (You don’t have to sign up to Twitch to watch.)

The office hours are largely to support iteratively running queries. People don’t take me up on this very often except via IRC because it’s hard to write these things perfectly out of the gate. Having a fast feedback loop is essential. Also, maybe having an open office hours session will be a nicely informal opportunity to answer questions and generally demystify the site.

If nobody has questions I’ll hack on the Lobsters codebase. Hopefully this encourages more activity on the repo. I’m also open to support people using the code to start a sister site, which is another activity that benefits from a tight feedback loop. (example)

I plan to stream weekly on (US Central) Monday afternoons at 2 PM and Thursday mornings at 9 AM in the hopes that this gives reasonable timezone coverage. Sorry for the inconvenience if you are antipodal to Chicago, though the site has always run on Chicago time. Sessions will probably run 1.5 to 3 hours and I’ll put summaries and transcripts in my archive for easy searching. I’ll try to keep the twitch schedule up-to-date and I already know I’ll miss 9/1 for a vacation.

This is pretty experimental! I did it a few streams back in summer of 2020 that went well, but everything was pretty chaotic that year for some reason and I dropped it. I did a technical rehearsal this weekend that went reasonably smoothly. If this continues to be interesting and useful, I’ll keep it up and try new things. Feedback here, in the stream chat, or by email (peter@ my domain) is much appreciated.

Special guest host will be my cat (subject to his schedule and whim). See y’all in our weird parasocial future.

There’s a more thorough description but #lobsters has three big purposes:

1. share a feed of links and have a lighter, ephemeral discussion on them
2. give potential new users a place to connect to existing ones for invites ⊕2024-08-08: To make an implicit value explicit, a big value of the chat is that it keeps our border a little porous, it helps Lobsters avoid becoming stagnant
3. some off-topic chat and community bonding

So we care a lot about text chat with a bit of custom functionality and a great new user experience. IRC is no longer a good experience for new users and a couple times a year #lobsters rehashes a discussion on IRC’s features and prospects. I finally realized I should collect my notes/logs into something linkable even if it’s only a braindump.

• Most of this is me comparing Discord to IRC because it’s the alternative that’s most-used by current chatters, but the Rebuttal section is pretty universal to any discussion of IRC’s shortcomings.
• I’m not seriously considering moving Lobsters chat to Discord, and the possibility is less attractive now that I’ve collected a list of its problems, which has built a compelling case it’s a bad culture fit.
• This is all pretty rough and contains a significant amount of frustrated venting.
• Items are not in priority order.
• Nothing here is urgent.
• We’ll use a chat for decades so any decision is less about current parity and more about trend lines.
• I’m compiling many discussions so we can rehash less in the future, whatever happens.

Desirable Discord Features

• good new user experience
  • GUI
  • familiar signup
  • if user already has an account, joining server is a link to a one-click join dialog
  • scrollback on join so the channel doesn’t look dead unless the new user joins in the ten seconds before an existing user hits enter
  • doesn’t leak IP
• desktop streaming (1080p)
  • I want to resume streaming Lobsters coding + office hours (esp for queries) ⊕2024-10-15: I’ve been streaming as hoped for a few months.
  • My attempts to contact Twitch eng about their login bug failed ⊕2024-07-18: Found it: Twitch’s login is broken if Firefox’s fingerprinting protection is on. I have to make a separate profile to use on-stream anyways, so it’s easy enough to leave off there.
• text formatting: links, bold, underline, italic, code blocks
• security - MFA, alert emails, active login list
• message editing
• emoji reactions (and allergic users can hide them)
• mod tools
  • reasonable banning (+b is garbage; separation of kick is misdesign)
  • no @ on mod names (https://libera.chat/guidelines/#channel-operators-are-users-too)
  • highlight/filter on keywords w great default lists
  • many high-quality 3rd-party tools (eg https://carl.gg/)
  • public modlog (might req carl.gg, I forget)
• mobile app
• good UI for muting channels/groups/users
• threads for breaking out overlapping/side conversations
• good user docs with screenshots
• per-server user profiles w bio, links
• I can pay for it and it improves over time
• can oauth to link account from lobsters profile
• file attachments
• higher discoverability/much better new user onboarding
  • #lobsters gets traffic from being ~25th in libera’s webchat top channel list
  • but discord is staggeringly popular and has 3p public directories

Discord Downsides

big stuff, potentially blockers:

• might not be able to disable donations (reasoning)
• mobile client sends a notification by default for any activity
  • painfully user-hostile and inappropriate for Community Servers
• slow even for a desktop GUI
  • a loading interstitial! takes seconds on a fast connection and powerful desktop
  • changing servers/channels takes x00ms and regularly much more
  • animated placeholders during delays
  • mobile app is noticeably slower at everything
• countless distracting animations, mouseover popouts, and mystery meat
• broken activity UI
  • not clear whether a channel is selected or has activity, both use bold
  • very flaky about marking channels as read (much worse on web than mobile)
  • messages from blocked users still highlight channel as active
• actively hostile to 3rd party clients/general hackery
• a serious culture clash that prompts most of the UI problems
  • Discord is oriented to mass-appeal to passive consumption of games, gossip, and memes
  • Lobsters is about creating, learning, sharing experiences/expertise

smaller stuff, antifeatures:

• no active ruby bot library
  • so almost every integration and workaround requires a 3rd-party service
  • I’m sick of trying to keep a js service running, but maybe I’m just underwhelmed by the IRC library
  • 355e3b notes webhooks get us ~all current functionality so I demoted this out of blockers
• threads/replies are clunky af
  • feels like they were bolted on the UI and never really integrated; even slack is better
• much more spam
• stickers, inline images, animated emoji
• enormous obnoxious link preview cards (no setting; maybe could delete by bot)
• intrusive upsells in clients (these go away on paid servers, right?)
• can’t turn off external link warnings even solely for our own site (sharing links is a core activity; we have sophisticated users)
• big company support (vs a libera admin is a lobsters user and active in the channel)
  • forum is overwhelmed by support requests/mental health crises
  • no chance of reporting bugs or influencing features
• complicated subscription structure with unclear pricing (but probably <$20/m)
• users can’t export logs
• no TUI
• no Reactions page collecting emoji reactions to own posts
• can’t disable X integration on profiles
• it’s so slow I have to list it a second time

IRC Rebuttals

• Fix/script your client
  • This is “baby why do you make me hit you” levels of helpful.
  • I would rather have one reasonable UI than have every user fail to reinvent the wheel.
  • Bad out-of-the-box UI is why IRC has rounds-to-100% new user churn
• So the server/client split…
  • I am a user, not an implementer. This is a technical decision that seems to have permanently hamstrung development.
  • It’s about as interesting and useful as a customer support line that refuses to help because you have the wrong department.
• Nickserv/chanserv/etc
  • Bolting on features/services via chatbot is powerful but bad UI (even when Discord does it!)
  • The big difference is that IRC never integrates these into the core product
• IRC is open source/open standard.
  • It’s nice and I’m willing to take a haircut for it, but I’m ready to take off the hair shirt.
  • But maybe being a protocol instead of a product is why it’s so far behind and not improving.
• IRC is volunteers/PRs welcome
  • IRC is a heroic accomplishment and should not be one
  • My time is more valuable than my money. For our non-toy usage $50/month barely registers as a cost.
  • Especially compared to the cost of joining a multi-stakeholder consensus-mandatory process about the redesign of legacy software.
• IRCv3
  • Mostly technical underpinnings with little addressing the feature gap.
  • IRC is not closing the gap. Discord is very actively widening the gap.
• Discord is a single service run by a VC-funded business
  • Lots of big, familiar privacy/sustainability/control risks here
  • This also prompts lots of the UI problems
  • VC B2C orients to growth metrics, so quality will nosedive hard when growth plateaus and the established processes can’t adapt to that “failure”

Underinformed Pontificating

Libera Chat isn’t at fault, incompetent, foolish, or anything else negative. Neither is the broader IRC community (well, aside from that one infamous guy, who is all of those things and more).

Most of IRC’s problems are structural. Network effects make chat valuable. But feature development has stalled beacuse it’s brutally hard to reach consensus. Maybe email and the web managed it because of competitive commercial use. Maybe the protocol isn’t as extensibile because it’s not as forgiving of unsupported features. There’s probably an amazing book waiting to be written about how open protocols and standards thrive or die.

Text-oriented group chat has products like Discord, Slack, Zulip, WhatsApp, Telegram, Messenger, WeChat, iMessage, GChat, Skype, Teams, Kik, Mattermost, Snapchat, Wickr, and then, you know, some small ones that only have tens of millions of active users. Nearly every human with a phone uses at least one. That’s a lot of room for open source and standards, and IRC seems to have attracted and extinguished potential development. Maybe the pressing thing to design is not a revised protocol but a process for sustaining consensus over revisions.

2024-07-12 Edit: Chat discussion has pointed out to me that Matrix is an open standard. I really only know it from the not-so-pleasant bridge to Libera Chat. I feel pretty good about putting “underinformed” in this section heading.

2024-07-26 Edit: When I published this blog post, the feed-reading bot shared it in the Recurse Center Chat. I had wandered away from it after my batch, mostly because Zulip was unpleasantly slow and janky. That’s been fixed in the years since, it’s a smooth and polished experience. I think it has all of the features listed here and none of the downsides (even an official TUI!), this is a plausible alternative. Zulip 9.0 was released today.

My last job had a codebase large enough (~50M LOC ⊕Edit 2025-02: I recently reread this post. I think this number must be too high, but I can’t remember what the right number was anymore, maybe 7M? But I don’t know how I would’ve made this mistake, it’s not clearly a simple typo. I guess I’ll just reiterate that it was by far the largest codebase I’ve worked in and not alter this post.) that there were always large-scale refactors in flight, which was a new experience for me.

One thing this article doesn’t specifically call out is that any kind of dependency update or replacement, whether an internal or external library, is a large-scale refactor. You benefit enormously if you can do this incrementally as the author describes instead of a flag day or One Giant Merge to update all uses. A counterintuitive result is that replacing one dep with another (foolib -> barlib) is easier than updating one (foolib 1 -> foolib 2)! Most languages do not allow you to depend on multiple versions of a package and have different sections of your codebase call different versions. Sometimes internally-maintained dependencies will rename just to get around this limitation.

There’s a style of managing dependencies that mandates you must wrap usage of libraries or APIs. Rather than calling Foolib::Thing.new, you’ll create your own FooThing (maybe using the decorator or facade patterns) and that class is the only place allowed to import from or call into foolib. With less exposure of foolib, it’s easier to create internal documentation, audit or control usage, or replace foolib with barlib. I don’t find this a cost worth paying in smaller codebases, but easily worth it in large ones.

Part of why it’s worthwhile is that it gives you two new methods for dealing with dependency updates. First (hopefully), you have a single codesite that uses foolib so a single team can make a small change to update foolib. Or second, if there are extensive changes that mandate changes at callsites, you can rename FooThing to FooThing1 (usually an easy, if large diff), introduce FooThing2 with the new API, and then use a process like the one this article describes to make that change incrementally to the entire codebase. Either you update foolib at the start of this process and FooThing1 maps old usage to new, or FooThing2 maps new usage to old and you bump foolib at the end. This process works quite well, whether foolib is an internal or external dependency. Whereas, say, emailing all-dev@example.com a link to the foolib release notes and dictum that on some particular date that all foolib usage must be updated will inevitably produce significant internal discord and never, ever an on-schedule completion. An even worse and more common failure mode for internal libs is to quietly mark foolib deprecated and direct people to rewrite to barlib when they show up with urgent questions about foolib during an outage - but of course good sense and steps 6-8 of the process described in the post would avoid such an outlandish footgunning.

(This post was originally a comment on Lobste.rs but then I realized it’s a nice excuse to break the 5.5 year dry spell here.)