benjamin wil

Unicode Variation Selector-15 and some of my tears

2026-07-13T11:32:26-07:00

From my phone, I noticed that my website was displaying footnote backlink glyphs as emoji in my RSS reader. It had not always been this way. I opened the same page from a desktop browser and saw what I expected to see: a text-like pictograph, in my article body’s font face. No emoji to be found. I checked the HTML document source:

<a href="#fnref:1" class="reversefootnote" role="doc-backlink">
  &#8617;
</a>

The RSS feed XML contained the same. So, that can be presented as either text or an emoji? &x8617; is an HTML representation of the Unicode codepoint U+21A9, Leftwards Arrow with Hook. This led me to many relevant threads, pastes, and blog posts¹ in which others had observed similar issues with Leftwards Arrow with Hook and other, similar navigation-decoration characters. We were all reacting to U+21A9 as rendered without a Unicode standardized variation sequence specified. So it’s up to whatever program is rendering U+21A9 to decide what to do. Which version, the text or the emoji, should U+21A9 render.

I found the correct solution and some less correct solutions to this issue. Before I describe them, I want to explore a slightly larger problem introduced by variation selectors.

The downstream effects

For meta-ish content characters like backlink glyphs, the way forward is clear for people who are technical: fix and/or configure the thing that builds your web pages. Or complain in the direction of the people who can fix and/or configure the thing.

For many of the other characters, it’s more complicated. Many of these characters are used in body content to be expressive. Rendering the text presentation instead of the emoji presentation, at worst, could be a mistranslation. The technical standard (see the emoji-data links, and specifically emoji-data.txt) lists over 1,000 Unicode codepoints that have both text and emoji presentations.

Codepoint	Glyph	As text (+`U+FE0E`)	As emoji (+`U+FE0F`)
`U+00A9`	©	©︎	©️
`U+00AE`	®	®︎	®️
`U+2328`	⌨	⌨︎	⌨️
`U+25B6`	▶	▶︎	▶️
`U+2603`	☃	☃︎	☃️
`U+2620`	☠	☠︎	☠️
`U+267B`	♻	♻︎	♻️
`U+1F310`	🌐	🌐︎	🌐️
`U+1F312`	🌒	🌒︎	🌒️
`U+1F37C`	🍼	🍼︎	🍼️
`U+1F441`	👁	👁︎	👁️
`U+1F509`	🔉	🔉︎	🔉️
`U+1F590`	🖐	🖐︎	🖐️
`U+1F635`	😵	😵︎	😵️
`U+1F636`	😶	😶︎	😶️

Table 1 A small sampling of the 1,000+ Unicode codepoints that have both text and emoji presentations. The Glyph column may look different to you, depending on the application you're using to read this article. I would hope the the +U+FE0E and +U+FE0F columns do render the same way for everyone.

There is no obvious, cut-and-dry user experience for writers here. Pictographs and emoji are regular text as far as most programs are concerned, and variation selectors remain invisible unless you go looking. Did the author mean to present an umbrella ⛱︎ or an umbrella ⛱️ ? We don’t know what their writing tool presented to them during editing. They don’t know that we don’t see what they think we see when we’re reading the thing. In a perfect world, all software knows about and inserts variation selectors for the user. In reality, we know that software is bad.

I found documentation that indicates that the Unicode Technical Committee is aware that variation selectors are complicated,² and maybe weren’t the best strategy.³ But what’s done is done and can’t be undone when it comes to the Unicode Standard.

The most correct solution

You can specify, in your source document, which version you want rendered. You do this by combining the variation selector codepoint with the preceding codepoint you want to render. In my case, that’s U+FE0E, Variation Selector-15. Using my source document’s backlink HTML markup as an example:

<a href="#fnref:1" class="reversefootnote" role="doc-backlink">
  &#8617;&#xFE0E;
</a>

And, if I wanted, I could do the opposite: force the emoji presentation, using U+FE0F, Variation Selector-16.

↩︎

Fig. 1 The pictogram via U+21A9 U+FE0E.

↩ ↩️

Fig. 2 The emoji via U+21A9 alone, next to the emoji rendered via U+21A9 U+FE0F, where U-FE0F, Variation Selector-16 coerces the glyph to use its full-colour emoji variant.

Fig. 3 Here's the image of the pictogram version and the iOS emoji version as rendered via U+21A9 alone. As I've already mentioned, which variant you see sans-selector can differ per application.

So, I can fix this issue for myself. I’m fortunate that I build the software that generates this website; and I’m fortunate that the library I use to generate HTML from my Markdown source documents (Kramdown) has a configurable footnote backlink glyph. There are authors using the Mistune library (for example, via the Bear blogging platform),⁴ or perhaps some other niche content rendering library, that don’t have the same luxury as of this writing.

Some less reliable solutions

If you’re in a position where you don’t control the software that builds HTML from your source documents, and, for some reason, it’s not possible to insert a variation selector character where you want it, there are some other things you can try. (At least for applications that use CSS for document presentation, like web browsers.)

font-variant-emoji

The font-variant-emoji CSS property is not currently supported in Safari. Hopefully it will be soon. It allows you to specify the preferred presentation of unicode characters for which ever DOM elements you like:

<article style="font-variant-emoji: text;">
  <span>Umbrella &#x26F1;</span>, or
  <span style="font-variant-emoji: emoji;">umbrella &#x26F1;</span>.
</article>

But I don’t think this can ever be a foolproof solution. Even wide web browser support doesn’t fully account for web content being presented by non–web browser applications like feed readers, and so on.

font-family: monospace

If you want an even less reliable solution, setting the font-family CSS property to the value monospace sometimes works:

<article>
  <span style="font-family: monospace;">Umbrella &#x26F1;</span>, or
  <span>umbrella &#x26F1;</span>.
</article>

But this only forces emoji-presented characters to be text-presented characters. And monospace is a generic font specifier that may look different from device to device.

Codepoint	Solution	Glyph	+`U+FE0E`	+`U+FE0F`
`U+26F1`	none	⛱	⛱︎	⛱️
`U+21A9`	none	↩	↩︎	↩️
`U+26F1`	`font-variant-emoji: text`	⛱	⛱︎	⛱️
`U+21A9`	`font-variant-emoji: text`	↩	↩︎	↩️
`U+26F1`	`font-variant-emoji: emoji`	⛱	⛱︎	⛱️
`U+21A9`	`font-variant-emoji: emoji`	↩	↩︎	↩️
`U+26F1`	`font-family: monospace`	⛱	⛱︎	⛱️
`U+21A9`	`font-family: monospace`	↩	↩︎	↩️

Table 2 A table demonstrating the less reliable solutions.

Here’s a short list of the most interesting links I found while looking into this:
- A Hacker News thread somewhere on the post about Google’s Noto Emoji font.
- “How to Prevent Unicode Characters from Rendering as Emojis in HTML with JavaScript: Force Classic Glyphs” on XJavascript.com.
- A question about “previous” and “next” arrows as rendered on iOS devices on Meta Stack Exchange.
- An issue on the Kramdown Markdown library from April 2015, still getting pings as late as May 2026.
↩︎
Holbrook, Ned: “Emoji Subcommittee Report for UTC #171 (2022Q2),” 22 April 2022 [PDF]:

A suggestion was made to emojify an existing character rather than add a new one. Regarding the proposed U+1FAAF KHANDA, Chris Hennick suggested the existing U+262C ADI SHAKTI be emojified instead. The ESC notes that doing so could affect the rendering of documents using ADI SHAKTI and that the UTC prefers distinct characters for new emoji for this reason [emphasis added]. ↩︎
Bettencourt, Rebecca; Ewell, Doug: “Proposal to disunify Symbols for Legacy Computing from emoji,” 14 October 2023 [PDF]:

The UTC has determined that unifying text and emoji characters was a mistake, and that attempts will be made to prevent further such unifications. The Emoji Subcommittee even has a standing agreement with the UTC to only propose new characters rather than adding the emoji property to existing characters, and to avoid creating new presentation sequences. The Symbols for Legacy Computing proposals have resulted in the opposite case of needing to use existing emoji characters as non-emoji; regardless, the requirement to prevent emoji unification still applies. Upon reviewing Buff’s proposal, the Script Ad-Hoc (including the members most opposed to the Symbols for Legacy Computing proposals) came to the consensus that the best approach is to propose these as separate characters. ↩︎
As evidence, here’s a link to an archived version of “Cities need more trees” on the Bear blogging platform by the creator of Bear, Herman Martinus, which uses Mistune to render HTML from Markdown. Currently, when I visit the webpage on iOS I see the full-colour emoji version of Leftwards Arrow with Hook instead of the pictogram. But in Firefox on my Linux distribution I see the pictogram. ↩︎

feed backfilling

2026-07-03T12:17:34-07:00

so my website has two main feed sources: the main weblog, and this antisocial feed that came into existence via rss club. until now they’ve been fully separate things, but i noticed:

other rss clubbers generally have a single unified feed.
based on some emails i’ve received, it seems like some readers here just don’t know about the main weblog feed.
from the feed reader’s experience, it could be a bit much to subscribe to me twice; i am not very important (positive).

so i decided to update this antisocial feed to also include posts from my main feed. i apologize if this update caused you any displeasure due to your feed reader marking some old-ish posts as unread or something. (the main feed will continue to exclude these all-lowercase antisocial entries.)

if you’d prefer, the classic antisocial-only posts atom and json feeds continue to live on at new urls:

all of this is actually helping me make the design of my static site generator better. in making this change i uncovered a bug. my rss feed builder supports building both atom and rss feeds. when i created this new selection of weblog and antisocial entries, i failed to ensure both canonical entry collections were set to use the atom format. this caused some entries to be missing encoded html in the built feed. excellent win for me, since my current development focus is making arbitrary entry selections, and feeds for those selections, a better experience.

Markdown is for humans

2026-06-25T12:21:51-07:00

Developers and nerds have seemed satisfied with Markdown as a plain text format for a long time. Now, I see Markdown approaching the edges of the mainstream. I casually mentioned Markdown in conversation with some of my schoolteacher friends and one of them nodded with recognition. That’s new. Maybe it’s because Google Docs enabled Markdown editing back in 2022. Or because, in 2026, Apple Notes enabled the import and export of Markdown-formatted documents.

Markdown’s creator, John Gruber, wrote that the surge in Markdown’s popularity could be attributed to widespread LLM usage. And yeah, I’ve definitely seen LLM output filled with Markdown. Maybe the schoolteachers see that, too.

Whether I’m speaking with software developers, technical writers, or schoolteachers, though, I see many of them misunderstanding what I think is the innovation of Markdown. Compared to the other historical plain text markup formats like Setext and BBCode, reading and writing full documents in plain text is easy and not syntactically perilous. Yes, Markdown does lend itself to rendering simple rich text and HTML documents. But it’s even more useful as a way to increase the information density of plain text files pre-render. Gruber summarizes it well in the same post:

Markdown isn’t really a “syntax”. It’s a set of conventions for formatting plain text. If everyone agrees to the same basic conventions, plain text can be significantly more expressive than a string of unformatted characters.

In the end, I’m grateful for projects like CommonMark working towards a complete syntax specification of Markdown.¹ But I worry that some of their decisions lean in the direction of Markdown that’s harder for humans to read. I already see Markdown documents written by authors who think of Markdown as a feature-complete markup language (it’s not) used to render richer documents. Maybe you, too, have seen an order list defined in this way:

1. The first list item.
1. The second list item.
1. The third list item.

Because GitHub Flavored Markdown, CommonMark, and a bunch of other implementations “correctly” interpret the intention of this as rendering a normal ordered list in HTML:

The first list item.

The second list item.

The third list item.

It’s my opinion that if you’re writing a list long enough, or complex enough, to benefit from using 1. as an auto-incrementer, you shouldn’t be using Markdown. Similarly, if you need to do some of the stuff that CommonMark implements for complex lists (see: “There can be any number of blank lines between items” and “loose lists”; insert blank HTML comments to generate two consecutive lists; consecutive list items with sub-indentation), consider other tools. CommonMark’s rules and tests are helpful, but they’re ultimately best for the machines and precarious for humans.

On the other hand, CommonMark and other Markdown specifications include some really great ideas that make Markdown-as-plain-text even better. I like Extended Markdown’s simple definition lists:

Lugger
: A small sailing vessel having two or three masts and a running bowsprit,
   carrying lugsails.

And I like task lists as popularized by GitHub Flavored Markdown:

- [x] Watch *Peter Hujar's Day* (2026).
- [ ] Watch *Cemetery of Splendor* (2015).
- [x] Watch *Rose of Nevada* (2025).

Notion, Discord, Slack, GitHub, and so on, have cemented Markdown as the way to jot down richly-formatted messages and draft simple documents. Markdown specification, implementation, and interoperability do matter and will likely matter more in the future. I just write this as a reminder that Markdown is for humans. My newlines should be for me primarily, the machine secondarily. And the fewer []{#unique-header-identifier}s I need to insert in my document source, the better.

An historical aside: CommonMark was originally dubbed Standard Markdown, but changed immediately to Common Markdown when Gruber objected. And then to CommonMark when Gruber objected again. If you read the Standard Markdown introductory post linked, you can see all of the reasons that led to a specification “needing” to exist. Gruber had been invited to collaborate on the project, but he left the CommonMark team on read. It’s clear now that CommonMark would inevitably clash with the one stated goal on Gruber’s Markdown project page: “The overriding design goal for Markdown’s formatting syntax is to make it as readable as possible.” ↩︎

I like JSON Feed

2026-06-17T15:24:15-07:00

Recently, I implemented JSON Feed support for my static site generator, Lifer. My impression is that, in 2026, JSON Feed is still not widely used, while people continue to rediscover RSS¹ thanks to the indie web resurgence and an appetite for re-decentralization. Bluesky supports RSS; Mastodon supports RSS; Substack supports RSS; even Reddit supports RSS²—but none of them support JSON Feed.

It makes sense for JSON Feed to be less popular than RSS: it’s not nearly as old or entrenched; it was created at a time, pre-Twitter implosion, in which feed reading had been subsumed by Twitter; and it doesn’t offer much new or different over RSS, so why bother. That said, after looking at my implementations of RSS 2.0 and Atom versus my implementation of JSON Feed, I found lots to like about JSON Feed.

The rationale provided by the authors of the spec isn’t written in a persuasive way:

We—Manton Reece and Brent Simmons—have noticed that JSON has become the developers’ choice for APIs, and that developers will often go out of their way to avoid XML. JSON is simpler to read and write, and it’s less prone to bugs.

Let me reframe this to be more compelling.

JSON is better than XML at storing HTML as data

In an Atom feed, you must encode HTML nodes inside of the <content> XML node so that they don’t look like the next XML node in the feed. This means, if you’re publishing HTML in your feeds, that the XML is even less human-readable than usual. See this excerpt from my blog’s feed:

  <entry>
    <content>
      &lt;p&gt;Here’s another blog post vouching for writing Ruby blocks
      using the semantic rule. Sometimes called “the Weirich rule”
      because of &lt;a href=&quot;
      https://en.wikipedia.org/wiki/Jim_Weirich&quot;&gt;
      Jim Weirich&lt;/a&gt;’s “Braces vs. Do/End” article&lt;
      sup id=&quot;fnref:weirich&quot;&gt;&lt; a href=&quot;#fn:weirich&quot;
      class=&quot;footnote&quot; rel=&quot;footnote&quot;
      role=&quot;doc-noteref&quot;&gt;1&lt;/a&gt;&lt;/sup&gt; and an issue
      he filed against &lt;
      a href=&quot;https://github.com/rubocop/ruby-style-guide/issues/162&quot;&gt;&lt;code&gt;rubocop/ruby-style-guide&lt;/code&gt;&lt;/a&gt;.
      The rule unambiguously answers the question posed by Weirich: “When
      should you use &lt;code&gt;{}&lt;/code&gt; for blocks and when
      should you use &lt;code&gt;do&lt;/code&gt;/&lt;code&gt;end&lt;/code&gt;?”
      His answer:&lt;/p&gt; <!--…-->
    </content>

I know you’re thinking that these feeds aren’t meant to be read by humans in the raw, so who cares. As a developer, though, wouldn’t you rather deal with simpler raw data? Here’s the same excerpt in JSON Feed (unminified):

"content_html":
  "<p>Here’s another blog post vouching for writing Ruby blocks using
  the semantic\nrule. Sometimes called “the Weirich rule” because
  of <a href=\"https://en.wikipedia.org/wiki/Jim_Weirich\">Jim
  Weirich</a>’s\n“Braces vs. Do/End”
  article<sup id=\"fnref:weirich\"><a
  href=\"#fn:weirich\" class=\"footnote\" rel=\"footnote\"
  role=\"doc-noteref\">1</a></sup> and an issue he filed against\n<a
  href=\"https://github.com/rubocop/ruby-style-guide/issues/162\"><code>rubocop/ruby-style-guide</code></a>.
  The rule unambiguously answers the\nquestion posed by Weirich:
  “When should you use <code>{}</code> for blocks and when\nshould
  you use <code>do</code>/<code>end</code>?” His answer:</p> ..."

JSON is more accessible than XML

JavaScript is one of the most widely-used programming languages in the world, and JavaScript Object Notation is a first-class feature of the language. In a JavaScript context, it’s easy to both generate and parse valid JSON.

Since parsing JSON takes no effort, even client-side in a web browser, I feel there are opportunities for us to go beyond feed reading and aggregation with JSON Feeds. The cost of parsing is so low, and the specified structure is simple. Desktop web browsers can even autoformat JSON to be nicely human readable³.

New programmers and non-programmers can make sense of JSON, and JSON parsing tools, pretty quickly. Feel free to pair this with my “HTML doesn’t need to be escaped in JSON Feed” argument above. RSS is just more abstract to read and slightly more error-prone to write. Given this, I think JSON Feed has the accessibility edge over RSS.

The standard exchange format is JSON

Many popular programming languages besides JavaScript also have first-class support for JSON. For example, I implemented JSON Feed generation support in Ruby using Ruby’s standard JSON library. Writing the implementation in Ruby felt no different than doing it in JavaScript.

The reason you’ll find JSON libraries built into so many languages is because it’s normal for API services respond to clients in JSON these days. In my experience, XML-based APIs have been eclipsed by JSON-based ones. Even as far back as 2011, a blog post by Dmitriy Samovskiy, “JSON vs. XML in API,” indicates that developers were realizing that designing JSON-based APIs resulted in a less complex system:

There is no easy and universal way how to represent nested hashes and arrays using XML (if there is, I hope to hear from you about it—I need stable libraries that can convert arrays and hashes to XML and back that could interop among each other for all major programming languages). Of course it’s possible and not terribly difficult, but it’s something that one must do.

Contrast this situation with JSON—you don’t need to worry about this, it’s already taken care of for you. The only limitation of JSON that we faced was that JSON doesn’t like integers as hash keys, it wants you to convert them to strings or use an array instead of a hash.

I would guess most of the software developers I’ve met and worked with, my age or younger, have never had to consume an API that responds in XML. (Even more of them may not know what SOAP is.)

If JSON is the standard exchange format, it makes sense that websites would benefit from providing content in that format so that content can be read… standardly. The longevity and resilience of RSS has made it the standard for website feeds, but we have watched the rest of the Web move on to JSON for good enough reasons. I’d say “why not JSON Feed?” since it already exists and is well specified.

Software developers are good at working with JSON

Implementing JSON Feed was a breeze. I compared my implementations of Atom, RSS, and JSON Feed generation side by side. They’re all shaped the same way, and there are only a few more lines of code to required to handle some RSS specification things. What made it a breeze was the simplicity of the JSON library API I was using: the public interface is minimal; the method names match my mental model for working with all kinds of (non-JSON Feed) JSON data.

My comparison revealed to me that the standard Ruby library for RSS is pretty bespoke and hasn’t been used by nearly as many people over the years. It’s not a bad library, but there’s so much friction that simply doesn’t exist when slinging JSON. It’s no contest.

Anyway, this website now has a JSON Feed if you’d like to subscribe to my posts that way.

By “RSS,” I really mean “Atom and RSS,” throughout this article. ↩︎
I couldn’t find official documentation for this. Just take the URL to any subreddit and add /.rss to the path, i.e. https://www.reddit.com/r/TVTooHigh/.rss. I’ll say, though, that in the past, the few subreddit feeds I subscribed would stop working… for months at a time. It may be more reliable to use a third-party subreddit RSS feed generator, if reliability matters to you. ↩︎
I often use Firefox’s JSON viewer. It’s good. ↩︎

taking the summer off work

2026-06-16T13:29:28-07:00

after deliberating for a while and doing some budget-math, i decided to take the summer off of work and attempt to recover from burnout. maybe i’ll write about that more over the next few months.

this is the first time since i was fourteen that i haven’t either been doing school or doing work (or doing both). as much as i know this break is necessary, i’m not looking forward to it yet.

as an adult, i have been risk averse when it comes to employment and money. i’ll be living leaner this summer, but i’ll be okay.

my intention this week is to create a calendar. i want to ensure that i’m not just rotting away in my apartment full-time. i’ll plan out things i want to go out and do; milestones for personal projects i want to make progress on; and well-defined chore goals (i’ve been putting off some things).

if you’re reading this and have experienced burnout, or are getting close, hello there. feel free to send me a message. :-)

SSH agent–managed SSH keys

2026-05-08T16:24:10-07:00

You probably already know: there’s no excuse to not be using a password manager in 2026. If you read my blog regularly, you may even be a person actually using a password manager. It’s possible, though, that you don’t use said password manager to manage your SSH keys.

If you didn’t already know you can manage your SSH credentials seamlessly in 1Password. You can do it with KeePassXC, too. I’m not going to mention the other big password managers by name, but at least one of them also already has built-in SSH agent support. Yes, the managers implement an SSH agent (see ssh-agent) and make authenticating via SSH feel kinda like authenticating to Netflix via a web browser.

More than ever, it’s a good idea to not store any credentials (or sensitive data in general) unencrypted on your disks. More than ever because there have been many notable instances of open-source software having recently been compromised via supply-chain attacks and backdoors. Group-IB characterizes supply-chain attacks as being hyped right now, which is funny and horrifying.

Between all the free-ish tools you use everyday and the LLM-related software your boss pays for, your computer is more an open wound, ready to be infected, than ever. You likely know this, I’m only here to remind you.

If, like me, you manage an environment or two where you don’t want to install a password manager, and you simply want to avoid leaving SSH private keys in plaintext, you can use GPG and a simple shell script to keep your credentials safe from prying mal-processes:

#!/usr/bin/env sh
#
# ssh-enc
#
# Usage:
#   ssh-enc <path to GPG-encrypted SSH private key> [SSH arguments]
# Example:
#   $ ssh-enc "$HOME/.ssh/vps.gpg" benjaminwil@example.com -vvv

encrypted_ssh_private_key_path="$1"
shift

ssh_arguments="$@"

eval "$(ssh-agent -s)"
ssh-add <(gpg --decrypt "$encrypted_ssh_private_key_path")

ssh "$ssh_arguments"

admitting defeat (re: android development environments on guix)

2026-04-26T13:26:28-07:00

for over a month i’ve spent a weird amount of my free time trying to set up an android development environment (via react native, and then nativescript) on my laptop running the guix linux distribution. i even had a bit of help thanks to some writing about this topic done by franz geffke:

unfortunately, i couldn’t take franz’s configuration verbatim and make it work. and beyond that, i also got nerd-sniped trying to make his setups more ergonomic for me. (i am slightly allergic to having to remember to manually open 2-5 shells, source a bunch of stuff, and then start a bunch of processes manually.)

on my own, i went down some rabbit holes, asked some questions in the #nonguix channel on libera, and attempted setting up my own bespoke environments via guix fhs containers, docker, and even a qemu virtual machine. the closest working environment was the qemu machine. that one at least did not require a bunch of harnessing to appease guix’s declarative, immutable nature. if even allowed me to connect to my physical android device without too much ritual. i abandoned that strategy, though, because it became a guix-related time-sink to learn how to set up a non-virtio filesystem so i could continue to run a code editor, etc. on my irl, non-virtual host machine.

could i get any of these strategies to work? with enough time, i think yes. but the personal-enjoyment accounting is already starting to be fucked up. this blog post is me surrendering and trying to not feel horrible about all of the time i have just admitted to losing.

no hate directed at guix here. i appreciate it the more i learn it. but i’m bummed out i couldn’t get the guix container with fhs emulation working with my physical android device. the core of the issue was that the adb server required for communication with a physical android device could not be run from within the container no matter what environment shit i told the container it could have access to. and running adb on the host didn’t “just work” with the processes inside of the container. with enough time, maybe i could get there. but at this point, i also just don’t know enough about the android sdk tooling to really be effective at creating the developer-harness.

new light colourscheme

2026-04-05T15:10:38-07:00

it’s a bit weird: yellows and blues and reds. what do you think?

my notetaking system, early 2026

2026-04-05T14:37:58-07:00

the process is still evolving, but i’m going to describe my notetaking system as of right now. i started from zero in novemberish last year and am getting happy with the cadence and quality of my notes as of starting this new system.

the biggest change that comes with the new system is that i’m now paper first, even if i’m sitting in front of a computer. the procedure for taking and processing paper notes is on a weekly cadence:

at the beginning of a week, start a new page with the date as a header.
create two sections on this page: consumption and todos. (usually consumption takes up two-thirds of the page, and todos one-third.)
create a third section starting on the next page: notes.
write down the titles of media consumed over the week in the consumption section. if i have additional thoughts or context to add for a piece of media, then an endnote indicator (a superscript number like ²) is added. then, the additional notes can be added to the notes section.
write down tasks to be completed for the week under todos.¹ if additional context for a task needs to be written down, the task gets an endnote, just like consumption media items. if/when i complete tasks, they get an X.
and then the notes section is pretty freeform, where each distinct note has a heading and/or references the endnote indicator from its antecedent consumption log or todos task.
at the end of the week, digitize all of the notes and save them to my personal wiki, where notes may get incorporated into blog post drafts, longer private articles about things i’m learning about, or emails i intend to send. by “digitizing” i mostly mean “type out”.
if i think an uncompleted todo items are important enough to carry forward, they get added to the next week’s todos section.

that’s kind of it for now. it’s a very lightweight process i don’t have to think about. i think the next refinements to occur will be on the processing/digitizing side of things.

because i tend not to live by task lists, i only write down aspirational tasks that i’d like to complete for the week, not every boring thing i need to complete to continue living. ↩︎

you're allowed to be uninsightful

2026-03-21T10:43:12-07:00

i’ve published two (small) non-antisocial blog posts this month, which is about one more than usual:

the topics probably aren’t interesting to most people, let alone most rubyists. but lately, i’ve been inspired by some authors and creators (rss club members included), and the edges of wikipedia, that are pleased to publish “the boring” information. i’m not trying to denigrate anyone by saying this. writing what you know, for yourself, to clarify your own thinking, and to present information clearly to the maybe one someone somewhere who needs to absorb it, is a good instinct.

said another way: i have relearned that we don’t have to write something that’s interesting to a giant venn diagram of people. most of us aren’t the new yorker and don’t need to be.

i know many of you reading this who write already know this. maybe one of you, like me, needs to be reminded.

one of the creators i’ve been inspired by is the biblical scholar dan mcclellan. to quote his bio:

his research focuses on the languages and history of the bible, as well as on the conceptualization of deity, of scripture, and of religious identity through the methodological lenses of cognitive linguistics and the cognitive science of religion.

he has made over three thousand videos now. he isn’t afraid to repeat himself. he says lots of boring stuff that scholars in his field know quite well. as someone with no credentials in this field, i appreciate that one of his goals is to better communicate what the consensus view of scholars is when in comes to controversial social and/or theological issues with regard to christianity in the west. he also is skilled at “stitching” videos that spread misinformation about christian shit and dunking on the content creators. sometimes he can get pretty mean.

i am not interested in many of the videos he publishes, and i definitely don’t watch them all, but seeing how consistent he is in form, content, and message, and how he bravely repeats himself in such a tireless way, gives me hope that i can continue to be at least as prolific as i’ve been this month.

cheers to us boring people.

Portable feature flags in ten-ish lines of Ruby

2026-03-21T10:18:36-07:00

It may make sense to use a mature feature flag library or pay for feature flags as a service in your complex application. That said, you can build pretty robust feature flags in just a few lines of Ruby:

require "json"

module Features
  class << self
    def as_json
      flags = self.public_methods - Object.public_methods - [:as_json]
      flags
        .to_h { |method|
          [method.to_s.sub("?", ""), self.public_send(method)]
        }
        .to_json
    end

     def éric_rohmer_mode_enabled? = enabled?("ERIC_ROHMER_MODE")

     private def enabled?(env_string)
       return false if (value = ENV[env_string]).nil?
       value != "false" && value.length != 0
     end
   end
 end

In this example, we track environment variables for each of our feature flags (just one, for now: ERIC_ROHMER_MODE). The interface returns a boolean value when we ask whether the given flag is enabled. Because we’re managing the flags within a single module, we can do nice things such as introduce the Features.as_json method to the current enabled status of all of our feature flags, meaning we can send this data to other systems and to web clients more easily:

Features.as_json
=> "{\"éric_rohmer_mode_enabled\":false}"

If you don’t need the portability of JSON, you can write even fewer lines of Ruby to get the same functionality by relying on truthy and falsey outputs instead of booleans.

As long as you keep higher-complexity methods like Features.as_json to a minimum, this module can easily grow with you as your need for weirder feature flags increases. If some features should only be available to users with a beta tester role, or you want to expose some functionality when a certain URL parameter is present, it’s just a matter of injecting your user object and your request parameters object:

require "date"
require "json"

module Features
  ÉRIC_ROHMER_LAUNCH_DAY = Date.new(1920, 03, 21)

  NULL_SCOPE = {
    url_params: {},
    user: nil
  }

  class << self
    def as_json(scope = NULL_SCOPE)
      flags = self.public_methods - Object.public_methods - [:as_json]
      flags
        .to_h { |method|
          [method.to_s.sub("?", ""), self.public_send(method, **scope)]
        }
        .to_json
    end

     def éric_rohmer_mode_enabled?(_)
       enabled?("ERIC_ROHMER_MODE") &&
         Time.now.to_date >= ÉRIC_ROHMER_LAUNCH_DAY
     end

     def infinite_money_enabled?(user:, **)
       enabled?("INFINITE_MONEY") && !user.nil? && user.beta_tester?
     end

     def preview_mode_enabled?(url_params:, **)
       enabled?("PREVIEW_MODE") && url_params[:preview] == "yes"
     end

     private def enabled?(env_string)
       return false if (value = ENV[env_string]).nil?
       value != "false" && value.length != 0
     end
   end
 end

As long as you’re keeping track of potential dependencies (NULL_SCOPE in this example) and passing in reasonable default values, Features.as_json still works sans arguments, and each flag check can independently be as complex as you’d like it to be.

JSON.parse Features.as_json
=>
{"éric_rohmer_mode_enabled"=>false,
 "preview_mode_enabled"=>false,
 "infinite_money_enabled"=>false}

JSON.parse Features.as_json(user: beta_tester, url_params: {})
=>
{"éric_rohmer_mode_enabled"=>false,
 "preview_mode_enabled"=>false,
 "infinite_money_enabled"=>true}

I’ve used keyword arguments in my interface because I prefer them to positional arguments. This ensures the flag method arguments remain legible in your application code and are easy comprehend by other readers. But as you can see, keyword arguments make flags a bit more annoying to write once you’ve introduced dependencies.

The most awkward thing here is that even feature flags methods that don’t require dependency injection must define an argument (_ or _unused). The second most awkward thing is that, only because we’re using keyword arguments, we need to pass a double-splat argument (**) to ensure, when Features.as_json is computing the given dependencies for each flag dynamically, irrelevant arguments are ignored without raising an ArgumentError. Luckily, the relevant dependencies remain very, very visible to anyone else reading.

Every codebase I’ve worked on deals with feature flags a little bit differently. I’d love to hear about what’s different in your application’s. (Send me a message!)

oscar predictions 2026

2026-03-13T21:14:30-07:00

these are not the things that i necessarily would want to win, but what i think will happen. (i’ve got nothing better to do.)

best picture: Hamnet

best actress: Jessie Buckley, Hamnet

best actor: Timothée Chalamet, Marty Supreme

best supporting actress: Elle Fanning, Sentimental Value

best supporting actor: Benicio del Toro, One Battle After Another

best director: Paul Thomas Anderson, One Battle After Another

best original song: “Golden” from Kpop Demon Hunters

best original score: Hamnet, Max Richter

best animated film: KPop Demon Hunters

best international film: Sentimental Value, Norway

best documentary feature: Mr. Nobody Against Putin

best casting: Marty Supreme

best sound: F1

best cinematography: Train Dreams

best original screenplay: Sinners, Ryan Coogler

best adapted screenplay: Bugonia, Will Tracy

best live action short film: Butcher’s Stain

best animated short film: The Girl Who Cried Pearls

best documentary short film: Children No More: Were and Are Gone

best visual effects: Jurassic World Rebirth

best production design: Sinners

best film editing: F1

best makeup and hairstyling: Frankenstein

best costume design: Frankenstein

Semantic style Ruby blocks

2026-03-08T16:06:46-07:00

Here’s another blog post vouching for writing Ruby blocks using the semantic rule. Sometimes called “the Weirich rule” because of Jim Weirich’s “Braces vs. Do/End” article¹ and an issue he filed against rubocop/ruby-style-guide. The rule unambiguously answers the question posed by Weirich: “When should you use {} for blocks and when should you use do/end?” His answer:

Use braces ({}) for blocks that return values.
Use keywords (do/end) for blocks executed for side effects.

An explanation

Let’s say we were iterating over some movies in order to print out their titles:

films = [
  "A Tale of Springtime",
  "A Tale of Winter",
  "A Summer's Tale",
  "A Tale of Autumn"
]

films.each do |title|
  puts title
end

An #each block only ever executes for side effects and never returns a value we can do stuff with. If we wanted to pre-format our list of films, we would need to iterate in such a way that mutates our film list (or creates a new list) before printing the films out:

films.map! { |title|
  title.upcase
}

films.each do |title|
  puts title
end

At a glance, a reader can see two different types of blocks performing two different functions: one mutates data; the other is executed for side effects (printing out a list of films). An author not using the semantic rule might have written this:

films.map! { |title| title.upcase }
films.each { |title| puts title }

Or this:

films.map! do |title|
  title.upcase
end

films.each do |title|
  puts title
end

Both of these are readable but do not communicate intent as clearly as the semantic style blocks. My primary goal when authoring code is to communicate my intent to other readers, so I appreciate the ability to be as precise in as few characters as possible.

Criticisms of the style

To me, there are two compelling reasons to be critical of semantic style blocks: the readability of do/end one-liners; and the inability of automated tools to format Ruby code consistently based on the semantic rule. I can agree that, sometimes, one-liners meant to execute side effects would make reading code more difficult:

films.each do |title| puts title end
# is less readable than:
films.each { |title| puts title }

But Ruby is so expressive that, in the off-chance you need to write a do/end one-liner, I’m confident there are other ways of achieving better readability without ditching the rule:

films.each do |title| puts(title) end

As for auto-formatting Ruby code while abiding by the semantic rule, this seems like a solvable problem in the long term. The “problem” is that Ruby is “too” expressive, and the tooling would have to understand a lot about the program and the author’s intent to reformat to braces or do/end correctly.

There is an interesting issue filed against standardrb discussing this. And, as of 1.0.0, standardrb has a relaxed, “let the author choose” approach to this block syntax. If you’re developing an application and your Ruby code is auto-formatted, I hope you will still choose to be intentional whenever you’re writing not-auto-formattable code.

Weirich’s blog is no longer online but is archived by the Wayback Machine. ↩︎

your mime type is showing

2026-03-04T23:21:54-08:00

hi. rss club showed up in my feeds today, and then i remembered that this feed is linked there and i haven’t used it in a while. and then i clicked on the feed and realized that nginx was rendering the feed with a mime type of text/xml rather than application/rss+xml. so i fixed that.

text/xml will likely tell your browser to render the feed as an xml in the browser. whereas application/rss+xml, application/atom+xml, and so on, will tell your browser to use whatever application is configured to be your feedreader. on my ios device, for example, clicking a link to this feed now results in a dialog modal. “open this feed in reeder?” it asks. this is much nicer than the browser rendering a fucking unstyled text file.

i noticed some other rss club feeds have similar issues, so if you’re reading this and you’re a clubber, do consider checking out your feeds.

on my main feed (html, rss) i succeeded in my informal goal of posting one-ish thing per month in 2025. i intend to keep it up, and maybe i’ll even throw some more stuff in this antisocial feed this year, too.

bye.

Victoria Film Festival 2026

2026-02-20T18:47:33-08:00

This month was the 32^nd occurrence of the Victoria Film Festival here in Victoria, British Columbia. It is likely the best-selling VFF in the history of the festival and featured ninety-one feature-length films from twenty-five countries. For a small city-like region like Greater Victoria, the festival operates at a higher level than we really deserve, despite the criticism that it’s “just” a “greatest hits” of other, larger 2025 film fests. It’s the best VFF that I’ve personally attended, and I think next year is probably gonna be even better.

Since I live and work in Victoria and was just living my normal life, I could only attend a handful of (ten) shows in the evenings, but I overheard others bragging about seeing twenty—and even thirty—movies over the course of the ten-day event. Do what you will with it: this article is just a rundown of the films I saw and how much I’d recommend them. We’re doing nebulous star ratings from between one and four stars (i.e. ★★★★) that take into account my enjoyment of the work and my enjoyment of the festival screening.

100 Sunset

Kunsang Kyirong, 2025, Canada

A Canadian immigrant story that I personally haven’t seen before, 100 Sunset is focused on the Tibetan diaspora in Parkdale, Toronto. Kyirong’s quiet directorial debut is bolstered by veteran (as far as I’m concerned) cinematographer Nikolay Michaylov’s effortless ability to make you feel like you’re in the subject’s head. It is full of challenging asshole characters and interesting story-decisions. ★★½

Nirvanna the Band the Show the Movie

Matt Johnson, 2025, Canada

I went in not having consumed any of the original web series or the television show. I was appeased, as were my friends who love the antecedent content. I really hope that the distributed cut of the movie will also include actual Back to the Future score samples. If you’re a sucker for time travel, gonzo filmmaking, or buddy comedies, you will have a good time. ★★★½

Beautiful and Neat Room

Maria Petschnig, 2025, United States

An unhinged tale about a working artist who can’t afford her Brooklyn apartment without short-term renting out her spare room to other people who can’t afford their own Brooklyn apartments. The principal actress, Charlotte Aubin, makes this work despite some of the dialogue (with a venti-sized cast of supporting actors) smelling slightly undercooked. You will leave hating every roommate you’ve ever had. This was the first, and only, film I saw at the makeshift thirtyish-seater cinema-venue Toaster Rocket located at Print Hole. I gotta say, this was a good venue. Maybe even better than the real cinema Screen 5 at the Capitol 6 where 100 Sunset screened.¹ ★★½

Pillion

Harry Lighton, 2025, United Kingdom & Ireland

The crowd loved it, and it was heartwarming. This is incredible considering the movie focuses on a BDSM relationship, which is an intense subculture that I’m positive ninety percent of the audience, including myself, know nothing about. A feat. Experiencing the narrative through the narrow, naive point of view of our protagonist, Harry, will remain burned into my long-term memory. ★★★

Blue Heron

Sophy Romvari, 2025, Canada & Hungary

Like 100 Sunset, this one is another feature-length debut by a Canadian woman-filmmaker. It amazingly, deservedly, has already been acquired for distribution by Janus Films. It’s a semi-autobiographical story about a Hungarian-Canadian family whose oldest child is struggling with mental illness. It brings a sharp, fresh perspective to the banal family tragedy movie we’ve seen many times over, and it incorporates both narrative and documentary elements in a surprisingly uncomplicated way. Despite the things I really didn’t like about it (millenial needle drops; [spoiler redacted]), it is probably my number one pick from the festival. ★★★★

Levers

Rhayne Vermette, 2025, Canada

I was excited and primed for this, having seen Vermette’s debut feature Ste. Anne a couple of years ago. This screening was in collaboration with local events promoter and zine-maker Destroyed Cinema. Destroyed programmed this screening to be followed by live music, which rocks. I think this complemented the film a lot. Levers kinda gives you a Guy Madden-high as you follow dozens of (almost a hundred?) extras in rural Manitoba during a mysterious pseudo-apocolyptic solar eclipse, leaving the town in darkness for seemingly a very long time. It was purportedly filmed on broken cameras, though I don’t think that stands out as much as it just having a bedroom-filmmaker, no-lighting, 1980s made-for-television look. There are also tarot cards involved. ★★★★

Rose of Nevada

Mark Jenkin, 2025, United Kingdom

A perfect follow-up to Levers, Rose of Nevada also looks like a cursed 1980s television show episode, albeit a bit more crackerjack. The gentility of the fishing village setting and warm, vintage look makes you forget that this is a hard The Twilight Zone episode. By “hard,” I mean good. ★★★★

The Blue Trail

Gabriel Mascaro, 2025, Brazil

A dystopian-future movie that’s more character than genre, and I appreciate that the character also happens to be a seventy-five year old woman. This premise alone gets at something we deserve more of in a time when nearly all of our genre movies are about rich people who are played by actors who are rich people who, at some point, have been in a Marvel movie. ★★★

A Useful Ghost

Ratchapoom Boonbunchachoke; 2025; Thailand, France, Singapore & Germany

Another directorial debut. I look forward to seeing more films from Boonbunchachoke, but unfortunately I gotta be mean about this one. It’s a black comedy that isn’t very funny and is probably an hour too long. It seems to me that there were too many cooks in the production-kitchen, which led to a lot of independently interesting story-ingredients being forced into an ambitious, professional, but ultimately unseasoned and conventional stew. ★★

A Poet

Simón Mesa Soto; 2025; Colombia, Germany & Sweden

To me, this feels like a 2000s indie comedy revival movie. It was revitalizing to see a two-hour movie about such a pathetic and misguided person with no jokes in it, but formally this movie has almost nothing going on. ★★

Not a huge compliment, but still. Screen 5, unfortunately, is the worst, smallest, dimly-lit cinema experience you’ll have in the city. You can see and hear the blood orange EXIT signs more easily than you can the movie you’re there to see. ↩︎

New website

2026-01-26T08:20:59-08:00

Today I’m launching my website redesign. I hope that you like it. Comparing the new design to the old one¹, my design seems to accidentally commemorate the soft ending of my career as a techincal writer. (I continue to search for and take software development roles.) We’ve gone from “bold and friendly” to “brutal and web-traditional” as I transformed from curious observer of software to grisled maintainer of software. The purple accent is gone and has been replaced with blues and blacks (in light mode) and yellows (in dark mode), and the IBM Plex Sans typeface has been replaced by your browser’s default serif typeface. For most of you, that’s probably Times New Roman, bread null butter. “Times New Roman,” writes typographer Matthew Butterick, “connotes apathy.” While I’d often agree, I wanna ask him if all stoicism is apathy, then? I hope my redesign broadcasts to readers my pragmaticism and connects me to the ancestral proto-social web where hobbyists and developers shared knowledge and experience for free, openly, via HTTP and RSS.

With the redesign comes new pages, as well: the colophon.

Here’s an example webpage archived by Archive.org. ↩︎

The best films I saw: 2025 edition

2025-12-31T12:00:00-07:00

As always, in an unranked order, here are the thirty best movies I was able to watch in 2025. This list was also published on Letterboxd.

I don’t think this year’s list is particularly interesting, except in that Hong Sang-soo has three entries and there are a couple (Aftersun, Sexy Beast) directorial debuts in here. If I had to throw these all out and pick out only one it’d be Haneke’s Benny’s Video.

Here are links to previous lists: 2024, 2023, 2022, 2021, 2020, 2019, 2018, 2017.

Charlotte Wells: Aftersun, 2022
Larry Clark: Another Day in Paradise, 1998
Michael Haneke: Benny’s Video, 1992
Jack Dunphy: Bob’s Funeral, 2024
Hong Sang-soo: By the Stream, 2024
Adam Curtis: Can’t Get You Out of My Head, 2021
Agnès Varda: Cléo from 5 to 7, 1962
Bill Duke: Deep Cover, 1992
Sidney Lumet: Dog Day Afternoon, 1975
Stanley Kwan Kam-Pang: Full Moon in New York, 1989
Tracey Todd: The Flavor of Cassava Leaf Over Rice, 2025
Sam Crane, Pinny Grylls: Grand Theft Hamlet, 2024
Hong Sang-soo: In Another Country, 2012
Leos Carax: It’s Not Me, 2024
Clint Eastwood: Juror #2, 2024
Werner Herzog: Lessons of Darkness, 1992
Alain Guiraudie: Misericordia, 2024
Kelly Reichardt: The Mastermind, 2025
Norman Jewison: Moonstruck, 1987
Richard Linklater: Nouvelle Vague, 2025
Wim Wenders: Room 666, 1982
Jonathan Glazer: Sexy Beast, 2000
Adam Curtis: Shifty, 2025
David Cronenberg: The Shrouds, 2024
Kristoffer Borgli: Sick of Myself, 2022
Ryan Coogler: Sinners, 2025
Boris Lojkine: Souleymane’s Story, 2024
Johan Grimonprez: Soundtrack to a Coup d’Etat, 2024
Hong Sang-soo: A Traveler’s Needs, 2024
Tsai Ming-laing: The Wayward Cloud, 2005

Porto, Portugal

2025-10-29T18:06:14-07:00

After EuRuKo in Viana do Castelo, I spent some time in Porto. In Viana do Costelo, some locals said that Porto is not as tourism-oriented as Lisbon. If that’s true, I can’t imagine how tourist-friendly Lisbon must be. I stayed near the historic centre of Porto, and it was quite touristic. The Wikipedia article about Porto has a little tourism section with links to articles and studies that indiciate that Porto has been fundamentally changed by an increase to tourism over the last twenty years. As a tourist-foreigner there, I can’t complain: it was an easy place to be a tourist.

Even on the outside of mainstream tourism destinations, Porto caters well to foreigners. For example, all of Cinema Trindade’s promotional and advertising materials were crystal clear about which films were being shown in English or had English subtitles available. Across the street from Cinema Trindade was a wine bar (FUNQ) operated by and filled with Porto expatriates. Batalha Centro de Cinema, a slightly more tourist-oriented cinema and cultural centre, seemed to have one Anglo-friendly showing every night of the week.

So Porto was a hospitable, pretty unique, and a very laid back place to take a vacation. If you’re going to Porto, I have a few recommendations:

I already mentioned The Batalha Centro de Cinema, which is not only a two-screen cinema but a cinema bookstore, bar, and gallery. There were posters all over the city for their David Bowie film series which was happening over the course of three or four months. Only having visited here twice, I don’t know the true health of this organization, but it gives me hope that the cinema isn’t actually dying. The book shop was special, as I don’t usually see so much literature dedicated to film in a single place.
The Guindalense Futebol Clube is a mostly outdoor pub on the edge of a cliff that looks out over the historic Dom Luís I Bridge and Vila Nova de Gaia and serves traditional Portuguese hotdogs and sandwiches. It’s a great view and a nice, cool place to sit.
Serralves is a great contemporary art museum. The programming that was on during my visit featured artists from all over the world, but to me the most interesting features were both Portuguese filmmakers. First, the permanant Casa do Cinema Manoel de Oliveira room and theatre, which celebrates the late Porto director and writer. In addition to bits of the filmmaker’s personal art collection and a synchronized projection of selected works, there is a video-library wall where visitors can watch entire films and browse information about Oliveira’s filmography. Second, Uma Coisa do Outro Mundo [A Thing From Another World], a video installation by Jorge Jácome featuring faux-documentary loops featuring disturbing (but funny) military personnel encounters with aliens.
Torto is an excellent cocktail bar. If you only go to one, make it this one.
If you’re looking for some gentle breakfast or lunch near Cedofeita, go to Hakko, a tiny lunch place with exceptional specialty coffee, a great plate of Turkish eggs, and a great record collection, or Bicho, a bright bakery and cafḗ just a block away.
If you’re still in Cedofeita, go to the Catraio beer garden for a huge selection of craft beer or Genuíno for an effortless family-style dinner paired with natural wines.
Also in the Cedofeita neighbourhood, Materia Prima is my favourite type of book and record shop. From their website: “Our interests are broadband, and not focused on any particular aesthetics. We operate with the most expansive and inclusive definition of culture, and work to make accessible to a widest public, the most adventurous, experimental, innovative and sometimes exotic artists, musicians, independent labels and publishers.”
Pastel de nata is a pastry that is literally everywhere in Portugal, it seems. Manteigaria is a chain of bakeries that made the best ones I tried. But honestly, each and every one I had was pretty good.

Viana do Castelo, Portugal

2025-10-01T14:02:53-07:00

I was at EuRuKo last month, held in a small city in the Norte Region of Portugal called Viana do Castelo. The conference was held in the Centro Cultural de Viana do Castelo, which is a really open, really impressive events venue and cultural centre built close to mouth of the River Lima into the Atlantic Ocean.

The word “castelo” translates to “castles,” and, yes, there are many historic castles and castle-like buildings throughout the city and larger Viana do Castelo district. If EuRuKo hadn’t been scheduled here, it’s unlikely that I would have ever known to come here, but I’m glad I did.

The fact that everyone front-of-house in the restaurants spoke English confidently also tells me that this is a destination for tourists, especially considering that this was less true in the other smaller municipalities I visited throughout the Norte Region of Portugal. This is probably also because it’s a destination on the Camino de Santiago. So what I’m trying to say is that it was an exceptional place for a foreigner like me to visit for a couple of days. If you’re going to visit Viana do Castelo, I can offer a few recommendations:

Sanctuarium is a bar and café at the top of the mountain of Santa Luzia, a short walk up from the towering Sanctuary of the Sacred Heart of Jesus. There’s a both a steep staircase and a funicular operated by the Church that can be used to get to the summit. Go to Sanctuarium on a clear day so you can see the city and the water down below. The garden seating here is enviable, and many locals had drove up to the top of the mountain to picnic.
Pacóvio is a tiny wine and tapas bar not far from the Centro Cultural. I found no better place to try the regional wine and low-key local food. I think it’s owner-operated, with just a single couple running the front-of-house and back-of-house by themselves.
Peloton Coffee and Cycling is a chill, slow coffee place if you’re in need of specialty coffee.
Ribeiro’s Brewers is a craft beer bar with an always-fresh tap list. When I visited, there were plenty small-batch Portuguese, Spanish, and German beers on the menu, and the staff was pretty excited to talk beer.

Catch-all routes and routing constraints in Rails applications

2025-09-19T08:48:50+01:00

I’ve worked with more than one Ruby on Rails application that has a catch-all GET route at the end of its config/routes.rb file:

Rails.application.routes.draw do
  resources :posts
  resources :users

  # This route is defined after all other routes as a catch-all.
  get "/*path", to: "fallbacks#show"
end

What this means is that there is a FallbacksController that handles any routing that isn’t already handled by previously-defined routes. In this simple example, a path like /posts/123, /posts/doesnt-exist, or /users/brock would be rightly handled by the resource routes that have been defined, but some other path like /about or /contact would be routed through FallbacksController#show. If the fallbacks controller becomes responsible for figuring out what content the user wants to view or rendering some other page like a 404 page:

class FallbacksController < ApplicationController
  rescue_from ActiveRecord::RecordNotFound, with: :render_404

  def show
    # If a page with the given path cannot be found, `#find_by!`
    # raises an `ActiveRecord::RecordNotFound` exception.
    @page = Page.find_by!(path: params[:path])
  end
end

This simple controller action looks the same way many other simple controller actions look, where the main difference is that we’re handling requests for any path not already handled by other routes. /about would route to our static page with a #path attribute of /about. /page-that-doesnt-exist would route to a 404.

When a catch-all route accumulates complexity

But the applications I’ve worked on that have implemented a catch-all route like this don’t intend to just serve content for /about or /contact pages. They all have implemented the catch-all so that they can present connected groups of pages that have a tree-like structure, like a taxon tree:

/unisex
└── /unisex/jeans
    └── /unisex/jeans/raw
└── /unisex/tops
    └── /unisex/tops/oversized

And using this taxon tree, they often want to present increasingly filtered-down groups of products for a product listing page.

The Rails applications I’ve worked on that provide this catch-all route have all stuffed a lot of complexity into their FallbacksController#show action.

For example, if we decide that some subset of pages should be rendered in some other way:

class FallbacksController < ApplicationController
  JEANS_SECTION = "/unisex/jeans"
  TOPS_SECTION = /unisex/tops"

  rescue_from ActiveRecord::RecordNotFound, with: :render_404

  def show
    path = params[:path]

    # If a page with the given path cannot be found, `#find_by!`
    # raises an `ActiveRecord::RecordNotFound` exception.
    @page = Page.find_by!(path: params[:path])

    if path.starts_with? JEANS_SECTION
      render "jeans_listing"
    elsif path.starts_with? TOPS_SECTION
      render "tops_listing"
    else
      render "show"
    end
  end
end

Now, even though we are rendering three different templates, our only dependency is a @page record. In this example controller action, the code indicates that our pages are basically all the same but can now be presented in three different ways. In my opinion that’s an acceptable amount of complexity.

But this can get out of hand fast if we want other variations of the product listing pages, or tack on other pages that require a top-level route like /about or /contact:

class FallbacksController < ApplicationController
  GRAVEYARD_CATEGORY = "graveyard"

  JEANS_SECTION = "/unisex/jeans"
  TOPS_SECTION = /unisex/tops"

  STATIC_PAGES = ["/about", "/contact"]

  rescue_from ActiveRecord::RecordNotFound, with: :render_404

  def show
    path = params[:path]

    # If a page with the given path cannot be found, `#find_by!`
    # raises an `ActiveRecord::RecordNotFound` exception.
    @page = Page.find_by!(path: params[:path])

    # Only include products that have been discontinued.
    @products =
      if path.includes?(GRAVEYARD_CATEGORY)
        Product.where(discontinued_at: ..Time.now, taxons: @page.taxons)
      else
        Product.where(taxons: @page.taxons)
      end

    render_404 and return if (@products.none? && !STATIC_PAGES.include?(path))

    if STATIC_PAGES.include?(path)
      render "static_page"
    elsif path.starts_with? JEANS_SECTION
      render "jeans_listing"
    elsif path.starts_with? TOPS_SECTION
      render "tops_listing"
    else
      render "show"
    end
  end
end

So here we’ve added a lot of functionality to FallbacksController#show.

the rendering of static pages
the rendering of a “product graveyard” for collections of discontinued products
the rendering of a 404 page if a collection of @products happens to be empty and we’re not trying to render a static page like /about.

Obviously this is a bit contrived; if we actually needed to render all of these pages from a single controller action, we might restructure it a bit. But hopefully this highlights the fact that… this should have always been served by many controllers.

Using typical Rails routes, undoing this technical debt could be a considerable amount of work, though, if we don’t want to break the existing routing. And, of course, maybe we do have requirements for static pages like the about page: that they are served via /about rather than /some-controller-prefix/about.

Reducing complexity using routing constraints

The least-effort way around the controller action stuffing would be use routing contraints, which allows us to stop stuffing all of this complexity into a single controller action. You can express this either as a lamdba or as a class that adheres to Rails’s contraints API:

class PageConstraints
  # Matches page paths. To be really nice, we'll optionally account for a
  # slash at the beginning and/or end of the request path. i.e. `about`,
  # `/about`, `about/`, or `/about/`.
  PAGE_PATH_REGEXP = %r{\A/?[^/]*/?\z}

  def matches?(request) = request.path.match?(PAGE_PATH_REGEXP)
end

class GraveyardCategoryConstraints
  GRAVEYARD_CATEGORY_KEYWORD = "graveyard"

  def matches?(request)
    request.path.match? %r{.+#{GRAVEYARD_CATEGORY_KEYWORD}.*}
  end
end

Rails.application.routes.draw do
  resources :posts
  resources :users

  # Example using a custom constraints lambda.
  get "/*path",
    contraints: ->(request) {
      request.path.match?(Product.known_category_prefixes)
    },
    to: "products#show"

  # Example using a custom constraints class.
  constraints GraveyardCategoryConstraints.new do
    get "/*path", to: "graveyard_products#show"
  end

  # Example using a custom constraints class.
  contraints PageConstraints.new do
    get "/*path", to: "pages#show"
  end

  # Aaaaaannd the old fallback route.
  get "/*path", to: "fallbacks#show"
end

I won’t include example code for all of the individual controllers, but I hope you can see how splitting the single, monolithic FallbacksController#show action into four separate controllers would make each of the actions much more maintainable.

See you at EuRuKo 2025

2025-09-09T12:15:46-07:00

I’ll be at EuRuKo, the European Ruby conference, in Viana do Castelo, Portugal, this month. Maybe I’ll see you there? We could grab a coffee.

Typesetting artist name–album title separation

2025-07-30T11:54:45-07:00

Recently I’ve had two occasions to think about how to typeset musical artist names when next to their album release names. I couldn’t find a very authoritative source on the subject, so I’ll offer up my own findings.

For music-related documents and user interfaces, you may sometimes need display an artist and album title next to each other. What are reasonable choices for separators? Publications like Pitchfork and applications like Bandcamp, Spotify, and Tidal try to side-step this issue by avoiding interface components where these two elements are displayed next to each other. They instead prefer to put one above the other on separate lines. That’s a reasonable solution, but let’s pretend it’s a luxury we don’t have.

Maybe the simplest solution would be to use different font styles for the artist and album:

Lizzy Mercier Desclaux Mambo Nassau

Let’s pretend we don’t have this luxury and that we must reach for typesetting separator-characters.

If we want to optimize for easy authorship, we could use colons:

Lizzy Mercier Desclaux: Mambo Nassau

However, colons sometimes appear in album titles. Especially if you’re attempting to present artist and album titles across many or all musical genres, this might not be the best choice. For some genres, like classical and contemporary art music recordings, colons might even create ambiguity (or readability issues) about which part is the album and which part is the artist:

Chen Pi-Hsien: Messiaen: 20 Regards sur l’Enfant-Jésus, I-27

There are other simple separators like commas and slashes that share this ambiguity problem. So we want to optimize for disambiguation, using an en- or em-dash seems to be safer, at least for now, in 2025:

Lizzy Mercier Desclaux – Mambo Nassau

Chen Pi-Hsien – Messiaen: 20 Regards sur l’Enfant-Jésus, I-27

Using dashes is also good enough for NME, iTunes, Apple Music, and Discogs to separate artist names from album titles, if that means anything to you. It does to me. Except in situations where sub-pixel real estate matters, dashes look good, are good disambiguators, and should be renderable by any font that’s any good.

If you’re considering using a hyphen instead of a dash: please don’t. Hyphens frequently appear in human names and album titles, and would not be a good separator or a smart disambiguator. I’ll admit that even dashes are an unusual separator character. But since they appear so infrequently in this context, they’re a shoo-in. For more information about the difference between hyphens, en-dashes, and em-dashes, I recommend the Butterick’s Practical Typography article about hyphens and dashes.

GitHub Discussions is modelled poorly for open-ended conversations

2025-07-22T20:12:56-07:00

Note that this article criticizes GitHub’s Discussions feature (originally launched in 2017) as it exists now, in July 2025.

In case you don’t know, Discussions is GitHub’s answer to forums and Stack Overflow-style Q&As. Users can reply to an initial message in a discussion and upvote, downvote, or comment on any response. In addition to announcement threads and polls, discussions can either be open-ended discussions or question/answer discussions.

Question/answer discussions:

can be viewed in one of a few sort orders (top voted first; newest first; oldest first) and
can have a single response marked as “the answer” to the discussion.

Open-ended discussions:

can also be viewed in one of a few sort orders (top voted first; newest first; oldest first) and
do not have any response marked as “the answer.”

The Q&A discussions improve upon the Stack Overflow model in an important way: the project itself is the owner of the discussion board. That means that project administrators are hypothetically present, moderating conversations and correcting potential mis/disinformation.

User interface deficiencies

Unfortunately, unlike the Q&A discussions, the open-ended discussions feature is an afterthought in comparison. Even visually, responses to open-ended discussions look disconnected from one another. Each response is an island, with borders, primed for its own disparate comments thread.

From left to right: comments on Discourse conversation, a GitHub discussion, and a GitHub issue. Of the three, the GitHub discussion stands out as having a visible textarea with placeholder text "Write a reply" between two messages meant to be read as replies to each other. It also stands out as visually separating the messages from each other. This design indicates that this isn't a discussion: it's meant to be listing of threads.

You might have noticed that the Discourse thread I captured actually contains a reply to an earlier message in the thread not shown here. This is a bit complicated, but regardless, the thread is still displayed in chronological message order.

While Discourse threads and GitHub issues both have their own user interface challenges and deficiencies, issues are displayed more like I would personally expect open-ended discussions to be displayed: a single conversation, without nested comments, and visually each message in the issue is linked to indicate a chronology. Interestingly, issues can be converted into discussions by project administrators–but not the other way around (for reasonable complexity-related reasons, I’m sure), though admins can create an issue from a discussion.

As a GitHub repository administrator, you must configure Discussions and the project’s enabled discussion categories. Each category will allow for discussions of one type (announcements; polls; Q&As; open-ended discussions). When creating a new discussion category, the default selected mode is question/answer. In my experience, this really shows. For example, see Laravel’s “Show and Tell” discussion category, which contains hundreds of “unanswered” links and plugs that members of the Laravel community may find relevant. No offence to anyone (I’m not a member of the Laravel community), but calling these “unanswered” feels like a mistake. Given this example, and the visual design of the discussion page, it seems clear that GitHub’s designers prioritized the functionality of the Q&A-style discussions.

All four discussion types have the exact same threading system, well-suited to Stack Overflow-like Q&As, and less well-suited for announcements made by project maintainers and open-ended discussions. For all four discussion types, responses can be upvoted individually and have their own nested comments threads. This specifically makes having an open-ended discussion quite complex: open-ended discussions are now not just open-ended, but also achronological, non-linear, or single-threaded, depending on how nested comments are (ab)used.

De-linearizing conversations

Years ago, I started a discussion on the Solidus project to have an open-ended discussion about how to handle a particular issue I was facing integrating with the Solidus framework’s provided frontend templates. There was no need for upvotes (or downvotes, thankfully), but all responders ended up commenting on a single response to the thread. The shape of this discussion would have been better suited to a single, flat thread, i.e.:

# original post -> [responses]

Original Poster   "Hi, this is a question or comment about The Project."
Responder 1       └── "Hi, this is a response to the question or comment."
Responder 2       └── "Hi, this is also a response to the question or comment, but I'm also in conversation with Responder 1, who responded before me."

rather than the tree structure it ended up as due to the GitHub Discussion’s design choices:

# original post -> [response -> [comments]]

Original Poster   "Hi, this is a question or comment about The Project."
Responder 1       └── "Hi, this is a response to the question or comment."
Responder 2           └── "Hi, this is also a response to the question or comment, but I'm also in conversation with Responder 1, who responded before me."

The tree structure makes the otherwise-linear conversation full of potential for non-linearity and complexity. After all, this is purportedly a single discussion. Imagine what this simple, linear conversation would look like with ten, or fifty, more participants.

Perhaps my discussion should have actually been a GitHub issue to begin with. Or, maybe, a message from the discussion should have been used as the source for a new issue. Well, it doesn’t matter. This discussion has long been abandoned and no action has been directly taken as the result of it. It’s meaningful that issues imply actionability and discussions do not, but I find it troubling that issues prioritize the chronology and linearity of a conversation while GitHub’s open-ended discussions don’t.

GitHub’s announcement blog post for Discussions describes the feature as “dedicated space for conversations,” and now, years later, that still feels untrue as I attempt to use these features or read past discussions. It also describes the feature as a way to “create a home for your community,” despite most discussion boards I’ve seen more closely resembling a community support, Stack Overflow-like Q&A feed.

“Just using it wrong”

There is a place for nested conversations. I don’t think the GitHub discussion I started is one of them. The nested response-comments makes the conversation look like the first responder’s comment is more important than the following comments. The structure and styles of the HTML document tell that story, too. Any discussion-readers not participating or reading closely might not understand that all of these messages are in response to the original discussion message equally.

You could minimize this by saying discussion participants are not using Discussions “properly.” Hm, but should a responder have to think that hard about whether to respond or comment on a response? Should they have to make this worse by accepting a previous commenter or responder’s decision to “use the feature wrong”? In the world of Stack Overflow-like Q&As, this complexity makes sense. For an “open-ended discussion” it does not.

GitHub’s own documentation about how to participate in a discussion is quite complex:

Comment in response to the original comment from the author of the discussion

Create a comment thread by replying to an individual comment that another community member made within the discussion
…

Upvote discussions and top-level comments to give them more visibility

As a way to describe the critical functionality of a message board, these participation instructions seem complex. Unfortunately, you can’t just say “reply to a thread,” or “contribute a message to the conversation,” because these things aren’t really conversations.

I don’t have much more to say about this other than I don’t think Discussions is a good form factor for most real, meaningful discussions, and they definitely aren’t good at being the primary forum for conversations being had by serious free and/or open-source software projects.

Prefer text over screenshots

2025-05-07T21:02:46-07:00

If you want me to read some text, use your computer’s text-copy commands to provide me with the data rather than taking a screenshot. There are a lot of good reasons to do this.

Screen size variability

The sender won’t always know how to format a screenshot so the receiver can read it easily. I’m sure that you, too, have pinch-zoomed your way across a wide image on a narrow touchscreen. Pinch-zooming your way across a wide image filled with text can make reading a slow and error-prone process.

Reliability and rediscoverability

Raw text content will always be more searchable than images. This allows you and others to rediscover the text when it is useful again later on.

I know that OCR exists and text can be extracted from images and videos in an automated way now. Unfortunately, I know too well that OCR is lossy and can even produce text with comprehensive typos. So, searching for text content from OCRed images cannot be as reliable as raw text content. Yes, even if you throw an LLM in at the end to help normalize the OCRed text.

Text can be translated

It’s true that raw text and OCRed text can both be translated into other languages. But I’d always feel more confident throwing the raw text into translation software for the reasons given in my previous point.

Text can be transformed

If you want me to read some text, you may also want me to decode, decant, or edit the raw text.

Without any specialized software, our computers are still good at text editing. Being able to copy text from one application and paste it in another is beyond convenient. Not only can you transform the text content, you can transform its display to better see or make sense of it.

Without any specialized software, our computers are not great at duping, editing, or processing image content. Having to manually re-copy text from an image or video is less efficient.

Text is portable

Going a bit deeper on that last point: text is more portable than an image. Text takes up less disk space, can be trivially opened by many softwares on many systems. Text can be printed out on even the most rudimentary of printers.

Why?

As a software developer, I often participate in message threads in which someone wants to discuss a piece of code or documentation, or a shapeless stack of log messages. Some senders would post a screenshot containing a representation of the text rather than the raw text. I never enjoy this, especially when I’m reading from my phone.

There may be real reasons they did this:

The software being used makes it too difficult to reliably select text (cheers, iOS).
The software being used makes it too difficult to copy text (cheers, Tmux).

For anyone with these reasons, I recommend finding other software that allows you to more easily select and copy text. Or, I recommend learning the difficult-to-use software’s select- and copy-commands. Or, as a last resort, I recommend recopying manually the text content you wish to send me.

You may be the sender and the text’s secondary reader for now, but in the future you may be the text’s primary reader. Make reading the text easier for yourself.

The Shrouds (2024)

2025-04-30T00:00:00+00:00

In one of the first scenes, Karsh explains to a date that the GraveTech cemetery he built, where Becca, his Jewish wife, is buried, is a “non-denominational” grounds. This isn’t quite the right word considering the inter-faith inhabitants of the cemetery. Karsh, a gentile, says that in the end he’ll be buried there, next to Becca. This is not the last time in The Shrouds that Karsh will use an exact, but incorrect, word. As a tech founder, it’d be normal for Karsh to misfield words. Many people with CEO-brain are naive to a fault and put boundless trust in the specialists around them. Karsh delegates to his dead wife’s sister’s specialist ex-husband Maury so that he can sleep, drive around in his Tesla, and emote.

It’d also be normal for the specialists and executive-types around him to use the wrong words. And they do, unless in this near-future Canada it’s accurate to call one’s AI personal assistant their “avatar.” An avatar is meant to be a representation of one’s self. Karsh has no avatar in the film. Although Karsh’s personal assistant Hunny represents him in video calls, she is importantly not Karsh, but a Memoji-esque representation of his late wife created by Maury.

I’m inclined to attribute the wrongful usage of the word “avatar” to the writer-director, who has an immaculate history of making the holiest vibes-based cinema. He need not care whether he gets things a little wrong, and his work is often more interesting because of what he gets wrong. Then, maybe he also means to say that after death, the manifestation of our loved ones say more about us than anyone else. We have Cronenberg on record saying that The Shrouds is “autobiographical,” inspired by the loss of his wife Carolyn. So Karsh is the avatar, a Cronenberg stand-in, and the Director-Artist who keeps the distorted love-memories alive through his own flawed creations.

Atom vs. RSS

2025-04-05T10:41:32-07:00

While working on my static site generator, Lifer, I was occasionally annoyed by how my test feeds were being read by RSS feed readers. And I was occasionally annoyed at the rss Ruby gem source code for generating XML tags in my feeds that I wasn’t explicitly specifying. Chris Wellons’s Atom vs. RSS blog post expresses the same feelings of surprise I felt when digging deeper into the ancient history that is the Atom and RSS 2.0 specifications.

This website has been ported to Lifer 0.9

2025-04-05T10:03:19-07:00

Since releasing Lifer 0.3 in January I’ve released six more minor versions to get the project stable enough to start using. The changelog entries don’t make the releases sound that interesting, but as an end user I’m much happier with the build performance, the tag support, and Lifer’s awareness of original publication and last updated dates.

Note to readers subscribed via a newsfeed: sorry if the feed has spammed you with new entries spanning the many years of this blog's existence. My Jekyll feed's settings were bad, and it seemed not worth it to me to make the feed's transition any more graceful.

benjaminwil.info looks and feels the same way it always did, but it’s no longer being generated by Jekyll–but by Lifer. There’s still plenty to do before I could cut a v1.

Lifer definitely has swerved out of the Jekyll clone lane into the could be a good and unique site generator someday lane, and I’m excited about some upcoming features that make it even more flexible for people who are willing to commit a bit of Ruby to their site repository.

From developer to Rails developer

2025-02-11T09:00:00-07:00

In 2023, I wrote this guide to getting familiar with Ruby and Rails for my employer, Super Good Software. In 2025, I wouldn’t change much too much about this article, which, I think, is a testiment to how mature and developer experience-focused the Ruby and Rails ecosystems are.

But I would stop recommending the Pry REPL now. In 2025, even the oldest supported version of Ruby now includes an enhanced IRB that provides many of the features I used to depend on Pry for. One can simply install the debug gem to get even more Pry-like behaviours from IRB.

Lifer 0.3

2025-01-05T13:14:00-07:00

I recently released 0.3.0 of my static site generator project Lifer, which I intend to use to build this website in the (near) future. Right now, I build this website using Jekyll, the “simple, blog-aware” static site generator.

Lifer and Jekyll have some things in common. For example, they’re both written in Ruby, and they both output HTML documents and RSS feeds to an output directory. They both read frontmatter metadata from Markdown files to help you maintain collections of pages and blog posts that belong to a small- or medium-sized website.

Jekyll has done me no wrong, but there are things about Jekyll I have found opinionated or hard to work around: Jekyll requires you to use Liquid templates for generating posts and pages; _posts is a bit too magic a collection of articles; its built-in asset pipeline is not very flexible.

It seemed like a good opportunity for me to try designing my own site generator, to see how simple I could make something I could use for myself, and to learn first-hand where all of the hidden complexity lies.

Now, 150-ish commits in, the shape of the site generator I want is coming together. I started this project, casually, over two years ago. So, at this rate, it’ll be a long time before anyone else can actually use Lifer. Testing the generator in production, though, will be quite a milestone. Stay tuned.

The best films I saw: 2024 edition

2024-12-31T12:00:00-07:00

In no particular order, here’s my annual list of the movies I loved that I saw for the first time in 2024. This year, I included two limited series as entries, which is a bit unusual of me. This list is also published on Letterboxd.

Here’s links to my previous years’s lists: 2023, 2022, 2021, 2020, 2019, 2018, 2017.

This year’s list:

Hong Sang-soo: The Woman Who Ran, 2020
William Friedkin: The Caine Mutiny Court-Martial, 2023
Théo Jollet: Meet Doug, 2021
Hong Sang-soo: Nobody’s Daughter Haewon, 2013
Tsai Ming-liang: Rebels of the Neon God, 1992
Ryûsuke Hamaguchi: Evil Does Not Exist, 2023
Robert Altman: The Player, 1992
Paul Schrader: Hardcore, 1979
Luca Guadagnino: Challengers, 2024
Harris Mayersohn: Stand Up Solutions, 2024
Bernard Rose: ivans xtc., 2000
Albert Serra: Pacifiction, 2022
Léa Mysius: The Five Devils, 2022
Bill Ross IV & Turner Ross: 45365, 2009
Bill Ross IV & Turner Ross: Tchoupitoulas, 2012
Abbas Kiarostami: Where Is the Friend’s House?, 1987
Paolo Sorrentino: The New Pope, 2020
Elaine May: Mikey and Nicky, 1976
Krzysztof Kieślowski: Three Colours: Blue, 1993
Éric Rohmer: A Tale of Springtime, 1990
Matthew Rankin: Universal Language, 2024
Miguel Gomes : Grand Tour, 2024
Sean Baker: Anora, 2024
Francis Ford Coppola: Megalopolis, 2024
Ira Sachs: Forty Shades of Blue, 2005
Payal Kapadia: All We Imagine as Light, 2024
Steven Zaillian: Ripley, 2024
Krzysztof Kieślowski: Three Colours: White, 1994
Hong Sang-soo: Tale of Cinema, 2005
Wim Wenders: Perfect Days, 2023

The best films I saw: 2023 edition

2023-12-31T12:00:00-07:00

As usual: here’s my annual list of the thirty best movies I watched for the first time this year. In no particular order. I also publish it on Letterboxd.

I’ve been doing this for a while now, so here are some convenience links to previous lists: 2022, 2021, 2020, 2019, 2018, 2017.

And now, the list:

Ryûsuke Hamaguchi: Wheel of Fortune and Fantasy, 2021
Abel Ferrara: Bad Lieutenant, 1992
Sofia Coppola: Priscilla, 2023
Hal Hartley: The Unbelievable Truth, 1989
William Peter Blatty: The Exorcist III, 1990
Dustin Guy Defa: Editing, 2021
Hal Hartley: No Such Thing, 2001
Michael Haneke: Funny Games, 1997
George Miller: Three Thousand Years of Longing, 2022
Olivier Assayas: Clouds of Sils Maria, 2014
Abel Ferrara: The Blackout, 1997
Hong Sang-soo: Claire’s Camera, 2017
Abel Ferrara: King of New York, 1990
Jim Jarmusch: Paterson, 2016
Eugene Kotlyarenko: A Wonderful Cloud, 2015
Michael Haneke: Caché, 2005
Kelly Reichardt: First Cow, 2019
Stanley Kubrick: Barry Lyndon, 1975
Ridley Scott: The Last Duel, 2021
Tsai Ming-liang: The Skywalk Is Gone, 2002
Larry Clark: Bully, 2001
Kelly Reichardt: Showing Up, 2022
Sebastián Silva: Rotting in the Sun, 2023
Michael Mann: Thief, 1981
George Sluizer: The Vanishing, 1988
Tom Noonan: What Happened Was…, 1994
Janicza Bravo: House Comes with a Bird, 2022 🎥
George Armitage: Miami Blues, 1990
Robert Altman: 3 Women, 1977
John Patton Ford: Emily the Criminal, 2022

The best films I saw: 2022 edition

2023-01-01T12:00:00-07:00

In 2022 I watched some movies for the first time, as I do every year. And these are the thirty¹ that were the best, most interesting, etc.:

Tsai Ming-liang: Vive L’Amour, 1994
Amalia Ulman: El Planeta, 2021
Pier Paolo Pasolini: Teorema, 1968
Spike Lee: Jungle Fever, 1991
Pier Paolo Pasolini, Vittorio De Sica, Luchino Visconti, Franco Rossi, Mauro Bolognini: The Witches, 1967
Mariano Llinás: La Flor, 2018
David Cronenberg: Crimes of the Future, 2022
Radu Jude: Bad Luck Banging or Loony Porn, 2021
Akira Kurosawa: Seven Samurai, 1954
Sophy Romvari: Grandma’s House, 2018
Paul Thomas Anderson: Licorice Pizza, 2021
William Friedkin: The French Connection, 1971
S. S. Rajamouli: RRR, 2022
Shirley Clarke: Portrait of Jason, 1967
Joachim Trier: The Worst Person in the World, 2021
Rhayne Vermette: Ste. Anne, 2021
Sofia Bohdanowicz: Never Eat Alone, 2016
Edgar Morin, Jean Rouch: Chronicle of a Summer, 1961
Jane Schoenbrun: We’re All Going to the World’s Fair, 2021
Steven Soderbergh: Schizopolis, 1996
Wendell B. Harris, Jr.: Chameleon Street, 1989
J. Lee Thompson: Conquest of the Planet of the Apes, 1972
Ti West: Pearl, 2022
Derek Jarman: Blue, 1993
Sofia Bohdanowicz: Maison du Bonheur, 2017

I’m counting La Flor as five movies because it’s 808 minutes long. Each year I try to get to a list of thirty, and some years it’s hard to. And this is one of those years. ↩︎

Providence, RI

2022-12-02T11:40:00-07:00

I was in Providence, Rhode Island, for RubyConf Mini and had the opportunity to eat and drink at some amazing places. If you’re going to visit Providence, I can give you the following recommendations:

Oberlin: Well-executed (!!) restaurant and bar. Try the raw bar. Try the pasta. Try the toast. Walk in early, or make a reservation.
Fortnight: Workers’s cooperative wine bar. Unpretentious. Cared for. Excellent wine and amaros menu (especially for someone coming from the west coast of Canada).
Haven Brothers: A long-time institution. Go inside to see how to fit a full kitchen inside a horse trailer, stay for a stupid hot dog.
Marcelino’s: An unusual hotel bar. Great mediterranean-inspired cocktail menu.
eddy: Thoughtful collection of wine, spirits, cocktails, and charcuterie. Definitely worth going here more than once.
AS220: A non-profit arts centre with a bar and live events, with lots of history. It’s got a Wikipedia page.
Pickerel: A tiny ramen bar. Interesting appetizers, drinks, and desserts. It seems like the people working there enjoy working there. While you’re in the neighbourhood: explore Luongo Square. If you’re waiting for a seat at the bar, go across the square to The Avery while you wait.

RubyConf Mini

2022-11-26T12:54:53-07:00

I attended RubyConf Mini in Providence, Rhode Island. If I met you there: it was a pleasure to have met you. This conference was a planned-last-minute conference, relative to its partner conference, RubyConf, in Austin. Their plan was to create much smaller, two-track conference for anyone unwilling or unable to go to Austin.

If the conference happens again next year, and you’re at all interested in the Ruby programming language, I would recommend attending.

777

2022-06-01T11:37:53-07:00

Recently I released an EP 777. You can stream it or purchase it on Bandcamp.

The best films I saw: 2021 edition

2021-12-31T12:00:00-07:00

As usual: here are thirty films, that I liked or thought were good, that I watched for the first time this year. In no particular order.

Éric Rohmer: Six in Paris, 1965
Angela Schanelec: I Was at Home, But…, 2019
Geneviève Dulude-De Celles: A Colony, 2018
Pedro Costa: Vitalina Varela, 2019
Jackie Chan: Police Story, 1985
Sean Baker: Starlet, 2012
Robert Altman: California Split, 1974
Éric Rohmer: Rendezvous in Paris, 1995
Spike Lee: Bamboozled, 2000
Thomas Vinterberg: Another Round, 2020
Éric Rohmer: Sign of the Lion, 1962
Juzo Itami: Tampopo, 1985
Stanley Kubrick: Eyes Wide Shut, 1999
Pietro Marcello: Martin Eden, 2019
Nicolas Winding Refn: Fear X, 2003
Solange Knowles: When I Get Home, 2019
Kevin Jerome Everson: Park Lanes, 2015
The Wachowskis: Bound, 1996
Wes Craven: Scream, 1996
Spike Lee: Da 5 Bloods, 2020
Apichatpong Weerasethakul: Blue, 2017
Tony Kaye: American History X, 1998
Tsai Ming-liang: Afternoon, 2015
Robin Hardy: The Wicker Man, 1973
Leos Carax: Annette, 2021
James Wan: Malignant, 2021
Jean-Luc Godard: First Name: Carmen, 1983
Corneliu Porumboiu: Infinite Football, 2018
John Maringouin: Ghostbox Cowboy, 2018
Dasha Nekrasova: The Scary of Sixty-First, 2021

Now a Gollum organization member

2021-11-02T19:04:00-07:00

Earlier this year, I was invited to join the Gollum organization after making some contributions to the main Gollum repository. I’ve been participating by triaging incoming issues and bug reports, reviewing pull requests, and contributing changes to improve the Gollum user experience for mobile users.

No longer there

2021-07-07T09:00:00-07:00

I released an EP called No longer there. You can stream it or purchase it on Bandcamp.

Treatise on Luck

2021-01-31T12:00:00-07:00

Mark Francis Johnson’s Treatise on Luck is a book of poems that investigates luck: where it comes from, where it goes, and where it isn’t. It’s a book from Gauss PDF, a digital publisher I am interested in.

From the book:

The grooming staple I’m never without is
XD’s Eau Sauvage. It was the first fragrance
I drank when I was young. In a way, it was
my first love. I am not sure if I’d still drink it
for the love I felt for it back then or the
fragrance itself, or for luck. It’s nostalgic.

The best films I saw: 2020 edition

2020-12-31T12:00:00-07:00

A marked improvement in my film consumption since 2019. The following list is thirty films long. All films I saw for the first time in 2020.

Alejandro Landes: Monos, 2019
Marcell Iványi: Wind, 1996
Éric Rohmer: My Night at Maud’s, 1969
Sofia Bohdanowicz: Point and Line to Plane, 2020
Federico Fellini: I Vitelloni, 1953
Jean-Luc Godard: Tout Va Bien, 1972
Louis Malle: My Dinner with Andre, 1981
Jim Jarmusch: Night on Earth, 1991
Jodie Mack: The Grand Bizarre, 2018
Pablo Larraín: Ema, 2019
Olivier Assayas: Carlos, 2010
Crystal Moselle: Skate Kitchen, 2018
Kazik Radwanski: Anne at 13,000 ft, 2019
Raoul Peck: I Am Not Your Negro, 2016
Nicolas Winding Refn: Pusher, 1996
Terrence Malick: Days of Heaven, 1978
Spike Lee: Malcolm X, 1992
François Truffaut: Antoine and Colette, 1962
Dash Shaw: My Entire High School Sinking Into the Sea, 2016
Paul Harrill: Light from Light, 2019
Peter Bogdanovich: Targets, 1968
Ladj Ly: Les Misérables, 2019
Spencer Williams: The Blood of Jesus, 1941
François Truffaut: Jules and Jim, 1962
Guy Maddin: Brand Upon the Brain!, 2006
Philippe Lesage: Genesis, 2018
Tsai Ming-liang: Walker, 2012
Scott Cummings: Buffalo Juggalos, 2014
Éric Rohmer: The Bakery Girl on Monceau, 1963
Lev Kalman, Whitney Horn: Two Plains & a Fancy, 2018

Assimilated

2020-12-25T12:00:00-07:00

I just released a new LaunchBar 6 theme called Assimilated.

I am kind of shocked that I still use LaunchBar, but as long as I use macOS for work I guess I’ll be using LaunchBar, too. Like Bijou, my five-year-old theme, I wanted a LaunchBar theme that would blend in with the macOS window chrome. With the release of Big Sur, I needed to create a completely new theme.

See the GitHub repo for more information and installation instructions.

Letter for you

2020-12-21T09:00:00-07:00

I released some music last week. It’s a short album called Letter for you. You can stream it or purchase it on Bandcamp. Bandcamp is also a great place to read the lyrics for each song.

I hope you enjoy the release.

prefers-color-scheme: dark

2020-09-16T12:00:00-07:00

i decided it was time to make a dark colour scheme for this website. i haven’t touched the styles on here in a while, and it was weird to go through them and see how my brain had decided to organize them.

i didn’t do a bad job. but, i dunno, definitely a younger version of me did it.

there’s no way to “toggle” the colour schemes on the website itself. it depends on you telling your browser (or in some cases your OS) which colour scheme you prefer: either light or dark.

Film Title Poem (2016)

2020-07-30T11:00:00-07:00

Please also read Jennifer West’s introduction to the film.

Of the many shorts I’ve seen that appropriate and then collage movie stills or sequences, I interpret Film Title Poem as one of the more appreciative ones. In it, Jennifer West shines a flashlight on many of the films in the western canon, the ones that either have weird staying power (Men in Black) or are held up as cult classics to the cinephiles (L’Avventura) or are the more obscure works of particular filmmakers who are considered canonical (Gus Van Sant’s Paranoid Park). There are even shout-outs to some very revered experimental titles (go T,O,U,C,H,I,N,G, Moth Light). I should also mention the expertly stolen soundtrack, featuring scores from Solaris among other movies I’m blanking on, even though the music is still as clear as can be in my memory.

When I say, “shines a flashlight,” I mean exactly that. As someone with warm feelings for the majority of these movies, I was happy to see them being rediscovered on this wall of film titles somewhere. The titles are presented in half-alphabetical order, half-some sort of order. In some moments I looked for meaning in the order: hidden sequences in the blinking, the repetition of some titles. I didn’t get very far reading the film like this, but didn’t mind either way. I was more focused on the Brakhagian scratches in the celluloid, highlighting movie-crushes and crossing out the (?) trash. Whether you can enjoy following along on this late-night tour or not, I think there’s value in flipping through these film titles with very little other context, re-evaluating them on the spot, re-evaluating my memories of them, and pitting them against the other film titles on the wall.

Self-hosting a tiny git remote

2020-03-22T12:00:00-07:00

There are plenty of full-featured git forges out there. If you’re a software developer, you’ve probably used GitHub, Bitbucket, and GitLab at some point – and you’re maybe familiar with Gitea, Gogs, or SourceHut.

All of this software is great, and each git forge has valuable features that save users time and effort when working on projects.

Sometimes, though, all I need is a simple git remote to sync a simple project. I don’t need issue trackers, wikis, continuous integration, or a way to manage patches coming from multiple contributors.

For these use cases, I have set up a tiny git remote that only I can access.

Create a synced directory

The first problem that needs solving: where should the remote live? I have chosen to use a simple synced directory.

There is nothing special about this directory. It is just another directory I intend to sync using some Dropbox-like file syncing software. (Don’t worry: I do not ever sync working directories. I’ll discuss this later.)

We have many ways to sync directories in 2020: whether you use a hosted service like Google Drive or use a self-hosted solution like ownCloud. I personally use Syncthing, which runs 24/7 on a media server in my living room – and then syncs to all my other devices whenever they’re connected to a network.

The directory I sync is simply called Git. It lives in my user’s $HOME directory.

If you’re asking yourself, “why not just use SSH?” right now, I suggest skipping to the Why not just use SSH? section of this article.

Add new repositories

The next problem is: how to get project-directory from Computer A to Computer B. The short answer would be, “use the synced directory” – but I want to do this the right way.¹

In my Git directory, I can start to initialize git repositories with the --bare flag:

git init --bare ~/Git/my-project.git

The --bare flag means that the git repository being initialized (or cloned, actually) is not going to be a working directory.

If I try to change directory to my new repo, git even warns me about this:

cd ~/Git/my-project.git fatal: this operation must be run in a work tree

You can read more about using bare git repositories this way in the Pro Git book. Specifically, see 4.2 Git on the Server – Getting Git on a Server.

Push to repositories

I’m about ready to push work. So far, I’ve:

Built a home for git repositories I want to sync: ~/Git.
Made my first bare git repository at ~/Git/my-project.git.²

Now, I can take any working directory and add my bare repository as a remote:

git remote add syncthing ~/Git/my-project.git

And when I’m ready to push my work from my branch (in this case my-branch):

git push syncthing my-branch

Clone repositories

When I’m ready to clone the project from another workstation, I just need to make sure my synced directory is available and fully synced. The messiest part of this is that (with Syncthing, at least) the synced directory may use a different path on my different workstations.

When I clone, it’s nice to manually set the --origin so I’m mindful that I’m pushing to and pulling from my tiny git remote:

git clone --origin syncthing ~/Git/my-project.git

And if I forget (like I often do), I can always change the name of the remote later using git remote rename:

git clone ~/Git/my-project.git my-project cd my-project git remote rename origin syncthing

Caveats

My tiny git remote works great for small projects I don’t intend to share with anyone. But I think it’s important to highlight the caveats:

If my syncing software fails (on the server or a client), I risk losing work.
If this is my only git remote, I risk losing work. I must use multiple git remotes.

If my syncing software does fail, but I’ve already cloned my project on multiple workstations, I may be able to recover. That said, I do need to be conscious of the state of my syncing software if I want to successfully use my tiny remote.

Why not just use SSH?

Some readers have rightly pointed out that this setup is more complex and has more caveats than just pulling from your other workstations via SSH:

git remote add workstation_2 benjaminwil@111.111.11.11:/home/benjaminwil/my-project

If I’m lucky: 111.111.11.11 is a static IP address that I already know. And if I’m really lucky: it’s just a domain name, like benjaminwil.info. Luck has nothing to do with it, but you know what I mean.

The reasons that I prefer using a synced directory, as described in this article, are:

There is built-in redundancy. Syncthing makes local copies of my latest changes whenever a workstation running Syncthing is on a network.
I am lazy. I am too often wiping my secondary devices and not setting up SSH keys to my primary devices.
I don’t personally have a static IP address at home. While there are ways to take care of that problem, I haven’t ventured down that path.

All that said, I also have a remote set up that I only access via SSH. It’s my “always off-site” backup, and it is very valuable to me.

I could technically work out of a project directory that’s actively being synced. But there are lots of files I don’t want to or need to sync.

Syncing would occur more slowly if I had to sync 200MB of NodeJS modules between workstations. And if I accidentally leave a process running on Workstation A and then start work from Workstation B, I could cause some weird problems for myself. ↩︎
I don’t have to add .git to the end of a bare git repo, but it’s a nice convention. ↩︎

The best films I saw: 2019 edition

2019-12-31T12:00:00-07:00

I watched a lot of mediocre and objectively-pretty-bad movies this year. So much so that I don’t think I can get to a list that’s thirty items’ long (as I did in 2018 and 2017). That said, I watched some pretty wonderful things:

James Benning: American Dreams (Lost and Found), 1984
Sofia Bohdanowicz, Deragh Campbell: MS Slavic 7, 2019
Virgil Vernier: Mercuriales, 2014
Bong Joon-Ho: Memories of Murder, 2003
Paweł Pawlikowski: Cold War, 2018
Kazuhiro Sôda: Campaign, 2007
Apichatpong Weerasethakul: Uncle Boonmee Who Can Recall His Past Lives, 2010
Ricky D’Ambrose: Notes on an Appearance, 2018
Agnès Varda: Le Bonheur, 1965
Lucien Castaing-Taylor, Véréna Paravel: Leviathan, 2012
Nathan Silver: Stinking Heaven, 2015
Sofia Bohdanowicz: Veslemoy’s Song, 2018
Manbiki Kazoku: Shoplifters, 2018
Toshio Matsumoto: Funeral Parade of Roses, 1969
Robert Hamilton: The Five Finger Splash, 2019 🎥
Rodrigo Sorogoyen: The Realm, 2018
Ethan Coen, Joel Coen: The Ballad of Buster Scruggs, 2019
Noah Baumbach: Marriage Story, 2019
Bong Joon-Ho: Parasite, 2019
Ryan Ermacora, Jessica Johnson: Labour/Leisure, 2019

Due to this feeling incomplete to me, here are some non-movie things that might have made this list in the parallel universe:

Mindhunter (season two)
Watchmen
Jane Campion, Gerard Lee, and Garth Davis’ Top of the Lake (season one)
Nicholas Winding Refn’s Too Old to Die Young

assessing my role in software freedom advocacy

2019-02-24T19:11:02-07:00

over the last year i’ve become increasingly conscious of how my life and work intersects with free and proprietary software. notably:

i spent the better part of a year enabling midsize companies’ ability to “make money” using an open source ecommerce framework.
i went from working a contract at a small consultancy – who invested a substantial amount of money into that ecommerce framework – to joining the consultancy and being acquired by… a very large company using the framework.
i became increasingly wary of people who make money via the internet.
i started thinking about other potential career tracks?
i switched from using arch linux full-time at work to using macos.
i saw some silly news stories about dicey open source software licenses.
i joined tilde.town and witnessed many people learning about and experimenting with free software – and it’s worth noting that there is a wider (still expanding) tilde subculture.
i’ve relied on amazon to provide me with many of my basic needs and convenience purchases, and i haven’t felt incredibly bad about it even though i think their existence is a net-negative for the world and the open web.
i reduced my reliance on google services – specifically g suite for email, calendar, and file storage, but i also started using duckduckgo as the default search engine in all of my browsers.
i started managing my own private git remote/server. it’s not impressive, but i’m always learning something.

this list is rambly, and it’s not clear what i (let alone you) should be taking from these experiences. today, this list is telling me my role in software freedom advocacy is too small. i say this as someone who isn’t interested in being a professional advocate of any kind, but as someone who loves computers, software, and the potential of the internet (which becomes undermined a bit more each day).

i can make my role larger by contributing to free software projects more and more often; by choosing to use free and open source alternatives to proprietary software (ahem, lucidchart); and by advocating for diy solutions to problems that big companies solve if you’re willing to throw money at them. most importantly, i can socialize the idea of software freedom when i speak to people inside and outside of the tech industry: i can write about it more, i can write about why i feel it’s important, and so on.

recently, i was introduced to the oggcast/podcast free as in freedom – which relaunched at the end of 2018 after a two-year hiatus. it’s hosted by bradley m. kuhn and karen sandler who are professional free sofware advocates. if you found my rambly thoughts on this topic semi-interesting, i’d recommend listening to the following (recent) episodes:

how to move into a new place

2019-02-06T18:04:22-07:00

i’m moving this month, and so far it’s going smoothly.

in the last nine years, i’ve moved ten times. most of the time, i only had to worry about my own things – but on one occasion i moved with two other people. i can’t yet call myself a moving expert, but i’ve become increasingly efficient at moving. i want to offer you, readers, some tips.

some of these are uninsightful, common sense tips – but things to hold close to your heart. when you’re moving: things get stressful, and common sense becomes… uncommon.

without further adieu:

don’t procrastinate

spend at least a week thinking about the move. and prepare to spend at least two days moving (if you’re able to take two days).

write out an inventory

and don’t inventory by room – rooms are too big. create zones that you need to pack, and use this to better plan your moving-tetris.

i super-recommend writing the inventory down, on paper or using a to-do list app on your phone.

plan to get rid of things

while you’re inventory-ing, make a list of things you no longer need – or need to replace. you could go the extra kilometre and make a list of things you don’t have but would like to.

again: write this plan down somewhere. it’s no good to you if you forget half of the plan.

plan to move the large things last

your small objects (books, records, kitchen objects, etc.) are the heaviest and most time consuming things to pack. get them packed and out of the way. these are also the easiest things to tetris and put into a moving vehicle.

overcommit

this can apply to your moving experience in a number of ways. for me:

i make sure more than enough family members/friends are available to help move (and that none of them would have to do too much work)
i make sure i have lots of time to deal with the move, and lots of time with moving vehicles, elevator keys, and what have you.
nothing is held together with paperclips. my boxes and bins work, and won’t fall apart.

alright, so these are my initial moving tips. as i continue this next moving process, i may need to amend them.

using jekyll collections for a secondary, rss-only feed

2019-01-21T23:17:12-07:00

this post outlines how i’m generating this feed as a separate, secondary feed using jekyll collections. this is completely possible using the current version (as of this post: 0.11.0) of the jekyll-feed plugin. this plugin is included in all new jekyll projects that have been generated with the jekyll new command.

the main blog feed for this site is at the default location:

https://benjaminwil.info/feed.xml

and the feed you’re reading from now is at:

https://benjaminwil.into/antisocial/feed.xml

collection names

there is one caveat: jekyll-feed doesn’t provide a way to set a custom name for your secondary feed. any other feeds you make use basic site metadata:

your site.title or site.name variable’s value
a pipe character with some spaces around it ( | )
and your collection name – with the first letter capitalized

this can look a little bit stupid if you aren’t careful:

Cool Website | My-new-collection

yeah, that’s the feed name that would show up in your friends’ rss readers.

i have a pull request open on the jekyll-feed repository that fixes this. but if you want custom names right now, you’ll have to use my fork of the jekyll-feed gem.

step one: update the jekyll-feed gem

when you create a new jekyll site using the jekyll new command, the version of the jekyll-feed plugin included is ~> 0.6. to create a secondary feed, you need to manually update your Gemfile to use jekyll-feed ~> 0.11:

ruby # Gemfile ... group :jekyll_plugins do gem "jekyll-feed", "~> 0.11" end

and add this git argument if you’re comfortable using my fork of the plugin (until my – or another similar – pull request has been merged):

ruby # Gemfile ... group :jekyll_plugins do gem "jekyll-feed", "~> 0.11", git: https://github.com/benjaminwil/jf end

step two: create a new collection

in your site’s _config.yml file, you need to add the name and metadata for the collection you intend to use for the feed. in my case:

yml # _config.yml ... collections: antisocial: output: true permalink: /antisocial/:name

output: true ensures a separate file is generated for each item in the collection (the permalink page), and the permalink: setting is probably familiar to you: use it to set your collection post’s uris.

the jekyll permalinks docs include a list of available collections permalinks variables. the variable i’m using (:name) just attaches the filename to the uri.

your new collection can be created in the directory _collection_name (unless you’ve set a custom collections_dir: in your _config.yml). in my case: _antisocial.

step three: pick a layout

you can either use your standard post layout or make a new one. if you’re a jekyll user, you likely know all about layouts: so i won’t go into any more detail here.

you can either set a layout: value in the frontmatter for every collection item, or you can set each collection item’s layout globally from your _config.yml:

yml # _config.yml ... defaults: - scope: path: "" # an empty string here means all files in the project type: "antisocial" values: layout: "your_preferred_layout"

this is some ugly yaml, but that’s what is has to be according to the front matter defaults docs.

step four: configure the feed

we’re pretty much done now. we just have to configure the secondary feed information using the provided jekyll-feed configuration settings.

again, in your _config.yml:

yml # _config.yml ... feed: collections: antisocial: path: "/antisocial/feed.xml"

where antisocial: is the name of your collection and the path: value is a string with your preferred feed location.

now that you’ve configured the feed, you can start to add new posts to your collection directory.

note that if you’re keeping a blog you still need to use date: front matter to ensure your posts get to the feed.

intro to antisocial feed

2019-01-17T17:01:34-07:00

test.

i’ve been made aware of a thing called rss club and i am interested in it. not just because i’m a feed junky, but because i’m nostalgic (even whimsical) for the web as i experienced it as a kid.

so, i’m calling this antisocial feed not to be antisocial towards you, reader. and not to be reactively anti–social media.¹

i’m calling it antisocial feed because of me: if you knew me, before we hit 201x, you’d know that i used to be social: i used to have curiousity, attention, and so on. i used to (think i had been) thoughtful about my (multitude of) interactions with strangers online.

i participated in forums: about video games, japanese rock music. i wrote collaborative poems with my friend staxu. these are not things i feel up to doing anymore, probably because i feel anxious about them: it’s vulnerable, or unprofessional, or exposing; i worry that i’d be misunderstood.

are there like-minded people out there? willing to communicate with me, even in passing? sometimes other people seem inaccessible to me. sometimes i am worried that the only people left are trolls or deluded alpha-male wannabes.

sorry – what an intro. i haven’t really made it clear what antisocial feed is going to be. for now, expect posts about the following topics:

how to (and how not to) communicate with others.
a ruby on rails-based personal journal platform i’m building: maeku.
irc, gopher, and free software in 2019. <3
movies that are okay. (i’m yet another rss club person on letterboxd – nice!)
why i’m not writing poetry for a living, even though that’s what i went to school for.

postscript

yeah, thanks for reading this far. i’m writing this on a static site generated by jekyll, and there’s no html view for this yet. it’s also separate from my main feed. more about this later.

reprise to self: all literature and media is inherently a little social. ↩︎

The best films I saw: 2018 edition

2018-12-31T12:00:00-07:00

For film-watching, 2018 wasn’t as good to me as 2017. But I did see a handful of movies worth remembering. The following list is thirty films long – all films that I saw for the first time this year.

Eric Baudelaire: Letters to Max, 2014
Spike Lee: Crooklyn, 1994
John Cassavetes: Love Streams, 1984
Alexander Sokurov: The Sun, 2015
Pedro Costa: Collosal Youth, 2006
Bingham Bryant & Kyle Molzan: For the Plasma, 2016
Jacques Audiard: The Sisters Brothers, 2018
Jonas Mekas: Reminiscences of a Trip to Lithuania, 1972
Sean Baker: The Florida Project, 2017
Luca Guadagnino: Call Me by Your Name, 2017
Steven Soderbergh: Unsane, 2018
Agnès Varda: Kung-fu master!, 1988
Steve James: Hoop Dreams, 1994
Tom DeCillo: Down in Shadowland, 2014
Boots Riley: Sorry to Bother You, 2018
Renata Gąsiorowska: Pussy, 2016 🎥
Ruben Östlund: The Square, 2017
Lynne Ramsay: You Were Never Really Here, 2018
Jacques Rivette: Wuthering Heights, 1985
Angela Schanelec: Passing Summer, 2001
Kevin Jerome Everson: Three Quarters, 2015
Benoît Forgeard: Respect, 2011
Paul Thomas Anderson: Phantom Thread, 2017
Denis Côté: Curling, 2010
Gastón Solnicki: Kékszakállú, 2016
Greta Gerwig: Lady Bird, 2017
Alex Ross Perry: Golden Exits, 2017
Éric Rohmer: La Collectionneuse, 1967
Yorgos Lanthimos: The Favourite, 2018
Wes Anderson: Isle of Dogs, 2018
Hugh Gibson: The Stairs, 2016

Bijou

2018-09-30T12:00:00-07:00

I updated my LaunchBar 6 theme Bijou (previously called El Capitan Small). Now, the theme has a dark variant to match macOS Mojave’s new dark mode. It also got its new name and features some small tweaks that make it more visually consistent.

See the GitHub repo for more information and installation instructions.

Public access Unix servers as a service

2018-07-21T12:07:00-07:00

A public access Unix (or Unix-like) server is just a computer. What makes it special is that anybody can sign up for a user account and use the computer.

I would consider these servers proto-social networks: no matter what activities you participate in on the server (message boards, chat, blogging, personal projects, shared application development), you’re contributing to the server community.

The most famous public access server is SDF. It has existed since 1987 and still has a growing user base. From 1987-era Gopher sites, to traditional web forums, to multi-user Minecraft, SDF hosts a wide-range of services for—and by—its users.

Currently, on the homepage of this site, I call myself a “public access Unix server enthusiast.” I began my journey with public access servers as a member of tilde.club¹ (unfortunately inactive these days), and I now contribute to tilde.town.

I understand that intentionally accessing a server via the command line, and knowing how to do that, is not something that every person can do or would want to do. However, I hope you consider the ways that these servers can offer spaces for social experimentation that can pave the way for future, more refined networks and online spaces:

These servers are fundamentally non-commercial. They operate on personal trust.
These servers promote technical literacy and offer the potential of education and mentorship.
Server information infrastructure is flexible and “designed” by active users. Users are the primary stakeholders, investors, and feature-implementers in their community.
Users intentionally create and have control over their own data.
These servers provide the opportunity for users to host their own unconventional websites, blogs, and web apps, for free (or some reasonable membership fee).

There is also talk of federating some tilde-named servers. You can see the beginnings of this at tilde.chat. Currently, tilde.chat connects four tilde-named servers via IRC.

For me, these are just a few reasons that make public access servers compelling. And seeing the recent success of Mastodon, and how it seemingly shares some of the same values, specifically around ownership, identity, and privacy. It validates my belief that these servers are forerunners in an emerging web culture, not just hobby spots for outsider tech nerds.

See Paul Ford’s article Tilde.Club: I had a couple drinks and woke up with 1,000 nerds for more information about tilde.club. ↩︎

Site update

2018-07-08T12:00:00-07:00

I just updated benjaminwil.info to use a new layout. It’s still built with Jekyll, and it’s still hosted on a DigitalOcean droplet—but I cut out fifty percent of the CSS and made site maintenance much easier for myself.

The best films I saw: 2017 edition

2017-12-31T12:00:00-07:00

I am sharing with you thirty films that I saw this year, that I liked. They definitely did not all come out this year, or even recently. They are listed below in a definite order.

Maren Ade: Toni Erdmann, 2016
Nanni Moretti: Sweet Dreams, 1981
Huang Ya-Li: Le Moulin, 2015
Jordan Peele: Get Out, 2017
James N. Kienitz Wilkins: Public Hearing, 2012 🎥
Jay Rosenblatt: Restricted, 1999
Ai Weiwei: Human Flow, 2017
Takashi Ito: Double, 2001
James N. Kienitz Wilkins: The Republic, 2017
Arthur Lipsett: 21-87, 1963 🎥
Casimir Nozkowski: IDAC, 2016 🎥
Michael Winterbottom: The Trip, 2010
Olivier Assayas: Personal Shopper, 2016
Kevan Funk: Hello Destroyer, 2016
Ousmane Sembene: Black Girl, 1966
Sofia Coppola: The Beguiled, 2017
Takashi Ito: December Hide-and-Go-Seek, 1993
Laura Poitras: Risk, 2016
Dana Berman Duff: Catalogue Vol. 6, 2016 🎥
Chris King: Wipe Poem, 2017 🎥
David Leitch: Atomic Blonde, 2017
Jeffrey Chong: Kingsway, 2017
Alabart, Cros, Verheyen, Rius: Agata’s Friends, 2015
Chris Marker: La Jetée, 1962 🎥
Jodie Mack: Wasteland No. 1: Ardent, Verdant, 2017
Maurice Pialat: À Nos Amours, 1983
Hayao Miyazaki: Kiki’s Delivery Service, 1989
Tom McCarthy: Spotlight, 2015
Tim Sutton: Dark Night, 2016
Peter Weir: Picnic at Hanging Rock, 1975

The Republic (2017)

2017-07-30T12:00:00-07:00

The Republic meets my threshold for something that is a movie, despite there being almost nothing to see. If you don’t already know: The Republic doesn’t utilize a camera. It presents solid colours only… and quite slowly. You could call it a gimmick, but be aware that it is one entry into a category of films that do the exact same thing—notably Derek Jarman’s Blue—and still manage to do a new thing. This entry holds interest by grounding the viewer in uncomplicated radioplay storytelIing, relieving us of the genuinely uncomfortable, OLED-destroying, static abstraction on screen.

Since you won’t be seeing much, pay attention to the warmth of the occasional flourishes that create sound-images in a mostly barren (apocalyptic?) sound-world. Most memorably, there is a doorbell effect that provides additional relief from what’s on screen, and from the detached, minimal presentation of sound stage and many of the vocal performances. I don’t have 7.1 surround at home and don’t believe this medium-fidelity production would have benefited from it anyway.

The story describes a group of libertarian outsiders (and e-cigarette enthusiasts) delicately. Here, in 2010s North America, the libertarians that get clipped are either loud or dangerous, and so I urge you to take a breath and reframe before watching, so you can “get behind” an extended scenario following the downfall of this sovereign of (very serious) libertarians who want deeply for their society to function.

Of all the performances, Nour Mobarak’s performance stands out.

Sleep when exhausted, revisited

2017-02-02T00:00:00+00:00

Three years after first presenting Sleep when exhausted, I was invited back to the University of Victoria to give a short talk about it in David Leach’s WRIT 324 class.¹ It turns out that giving a talk is the best possible excuse to revisit old work, especially when you’re a little embarrassed about it.

This post is based on that talk. It also attempts to extrapolate on the jokey, cryptic stuff that appears in the essay that accompanied the project.

What is this thing?

Sleep when exhausted is a looping visual poem.² That means that it begs to be read over and over again. If you choose to go through it more than once, you’ll notice that the poem changes depending on the lines you pick out. But the premise of Sleep when exhausted, at its simplest, is that it’s a poem.

For me, re-reading poetry is a necessary part of reading poetry. Every time I read a poem, I’ll linger on slightly different details, or the same singular detail with some other cadence. This project formalizes that re-reading process. Unless you’re mapping out the lines that you’re picking, you probably won’t go through Sleep when exhausted the same way twice.

Even now, as I’ve been going through it again, I get surprised by certain things that I don’t even remember writing. Like the clock that reads 99:99 on the piano in the living room.

Why make a poem out of a website?

I received something that the University of Victoria calls a Jamie Cassels Undergraduate Research Award. It’s given to two students from every department each year.

In addition to $1,500 toward tuition, recipients get a $50 stipend to spend on poster materials for the eventual JCURA year-end fair. If you’ve ever been to a high school science fair or a college job fair, just picture that, but with a wider array of disciplines represented.

Because I was not required to use my $50 stipend on printing materials specifically, I didn’t. My favourite science fair projects, as a kid, were the ones where you didn’t just read a poster. I figured I’d make something a little more interactive for my visitors to deal with. So, “Why make a poem out of a website?” That’s why.

What’s with the accompanying essay?

It’s a poemy, tongue-in-cheek window into the nature of my research. While I think there’s overlap between “creative research” and “academic research,” creative research doesn’t follow the same rules.

The academic research that I’m most familiar with as a university graduate feigns uncontaminatedness and objectivity toward its subject. Although academics might start research out of a place of curiousity or passion, they may need to squelch some enthusiasm, or their research may stay unpublished. Rightly so. There’s value to that system.

Meanwhile, creative search can start in the same place—a place of passion—but sprawl across disciplines and styles and remain unsquelched. See Jordan Abel’s book Un/inhabited, which documents the colonialist language used in copyright-lapsed (read: very old) western novels about land and land ownership.

The “creative thesis” is getting more and more popular, but it still doesn’t have the same clout that an “academic” thesis has. I don’t want to say that a creative thesis is less legitimate, than a “non-creative” thesis, but they do have a way of making uninteresting subject matter more interesting.

My own creative research here, and the way I present that research, has less to do with deep dives into external materials or studies and more to do with sleepy reflections on the loss of personal motivation, focus, and feeling like life sure is boring. I don’t want to say that my research is less legitimate, but I’d agree with you that it’s less interesting.

Are you one of those “video games aren’t art” people?

It sounds like you’re referring to the section in the essay about “gameness.” In it, I say that Sleep when exhausted falls outside of what I’d normally consider a game.

I’m not a “video games aren’t art” person. I just don’t think this is a video game. You can’t really win, and the poem’s mechanics aren’t skill-based in any way. The mechanics—clicking through a line to get a new set of lines—are barely even narrative. I see the forward motion of the poem the same way that I see my own thought process: not focused, only somewhat linear, and attention-averse.

Is this work scrappy?

Yeah. When I started this, I had no idea how to build a branching narrative for the web, and I had no idea what the poem’s content would be. I did outline some of it, to gauge the general trajectory, but as I was implementing the trees I veered quickly into doing whatever I felt like at that moment.

I experimented with doing the whole thing in Twine, but I had a hard time getting the non-linear, wrap-around, lost feeling using that system.

Please, please, please don’t look at the source code for this effing thing.

Does this thing have a structure?

I guess so, but I’m still not able to parse it completely. Or, making a perfect map of this poem (by hand) would be quite difficult. There are a lot of “potential poems” in here, and while I’d love to see them all extracted into a series of separated poems—there would be a lot of them.

However, this thing does have a system. There are three types of states:

Observation trees (I went to the kitchen / I went to the bathroom / etc.)
Streams of consciousness (I / love / Maria)
Clarities (I was bored / /)

It’s nice to have system language for what this thing is, but I don’t think it makes the work any more interesting. Just jump in and see how it makes you feel.

Where’s this source code I’m not supposed to look at?

You can find the source code at this GitHub repository.

The class is called Writing Interactive Narrative: “A workshop/seminar in writing for digital media, hyper-literature, video games, interactive installations and experiences.” ↩︎
I call it a “visual poem” because the white space, three-column layout, and the nature of content-forking are very central to the piece. Although I can see why someone would argue that it’s not visual poetry according to the definition. ↩︎

El Capitan Small

2015-12-26T12:00:00-07:00

I made a theme for LaunchBar 6, a Mac OS X-based launcher and automation tool. It’s inspired by Small, the default theme for LaunchBar 5.

It’s called El Capitan Small. See the GitHub repo for more information and installation instructions.

Sleep when exhausted

2014-03-05T12:00:00-07:00

The technical content of Sleep when exhausted, to anyone viewing its page source, is not by any means impressive and is crudely constructed. Still, as a product I would label foremost as poetry, I will offer here that the amateurish build quality adds to the final product.

Process

What I created for this project records my coming to the web browser as an outsider. I spoke colloquially, as a poet, using JavaScript to speak to the client’s web browser in a language that the browser understands. I utilized the browser’s ability to calculate the unfolding narrative efficiently, in a way that readers need not understand.

And so, because I am a barely self-taught web developer, and still wanted to see the poem laid out somehow on the backend, I created much unnecessary work for myself. I often had to backtrack.

This became a contemplative act in the same way that prayer is a contemplative act: instead of humbling myself before the greatness and nonhumanness of other, I approached other as though other wanted to be spoken to as if it were humanlike. The only communicative benefits, as far as I understand them, that can be observed from an act of prayer are in oneself; other’s involvement in the conversation was not observable.

A practiced web developer could find more efficient ways of creating Sleep when exhausted. Instead of inputting each state¹ by hand, I could have created a collection of data that, with simple keywords, would grab any input data and automate the output. Instead I chose to approach the JavaScript like I do any analogue writing project:

I assume that I understand the language I will be working in well enough to communicate something.
I research in isolation, without input from mentors or peers until later in the process.
I work linearly, one minuscule task after another.
I check for errors and mistakes and inconsistencies.
I repeat.
I disregard orthodox form and structure,
which might also mean disregarding common sense, readability, and usability.
I embrace the long hours and unpaid nature of my project.
I stop eating, sleeping, et cetera.
I take long walks in the middle of the night when restless.

I do not mean to say that conventional web development cannot be a contemplative or transcendental act. I only mean to distinguish between conventional web development, which I know little about, and my own emulation of web development as a poet in a culture of poetry steeped in printed matter.² I also understand that many web designers, developers, students, and other creatives work in a similar, albeit unhealthy, way—working more than eighty hours per week, losing sleep, eating poorly, being obsessed, or whatever.

Gameness

Because the reader generates new information to consume as they navigate through the speaker’s world, Sleep when exhausted could be closely compared to Choose Your Own Adventure-style gamebooks, other branching narrative systems, graphical point-and-click adventure games, visual novels, or whatever.

The major difference would be that Sleep when exhausted excludes actual choice, plot, and gameness.³ Readers might view themselves as “players” when interacting with it, but more than usual, their choices have no effect on this work’s outcome. Readers pick the details that they pick, and details unveil further details as I have prescribed. The continuity is not narrative, or, because it is looping, chronological. It is just a visual artifact of the speaker’s consciousness, much like other poems.

Reading

In avoiding gameness, I knew that my project would withdraw further into the territory of poetry—a region that seems to exclude the majority of people—and even the majority of writers. I wanted poets and nonpoets to be able to approach this work. I created an imaginary general audience. So I worked to cater to a diverse set of readers, who have short attention spans, or read more or less in the context of video games, or who more or less read links acquired from their Facebook feeds.

Similarly, I did not want to alienate the “average reader”⁴ or the “average reader of poetry” any more than usual and decided to make Sleep when exhausted seem book-like. This is my tiny attempt to trick them into interacting with the work.⁵

If I ever wanted this imaginary general audience to enjoy, let alone interact at all with this work, it would need to be completable in under a minute and absorbing enough to invite readers interested in the work for another read.

Literariness

There is a girl seated in front of me, sitting next to her mother. She is twenty-three-ish years old. Our flight attendant passes her a glass of water. I watch her watching Jeremy Renner fight a wolf with his bare hands.

I’ve already seen The Bourne Legacy, but it seems different now. I am trying to scrub through my memory of the flick, figure out what events have already occurred. I view this now without audio, through the crack between two airline seats. I attempt to measure the viewer’s pleasure, filtered through her blonde, shoulder-length hair.

Our flight attendant passes me a glass of orange juice with ice in it. It takes a few minutes, but I finally find the dimmer to turn off my own in-flight multimedia station. I admit there is something about watching a movie you have no intention of finishing because the duration of your flight just isn’t long enough, but today I want to just be on this airplane and do nothing.

Obsolescence

As web browsers are perpetually modernized, support for Sleep when exhausted will likely drop, at least partially. This type of problem affects all digital works and will impair us from interacting with content as it was intended—at least until content creators adopt plain text as the standard method of digitally storing and/or documenting human-readable information⁶ or move back to paper.

Sleep when exhausted will also become visually obsolete as it ages, and is probably ugly already. I regret aesthetic choices that I have made. That said, I do not intend to continue support for this work, and I welcome any obsolescence gratefully.

Reading list

From Modernism to Hypermodernism and Beyond. Armitage, John; Virilio, Paul
Post-digital Research, vol. 3, issue 1.
Manifesto for Concrete Poetry. Fahlström, Öyvind
Instructions for Lightning Avoidance. Fee, Matthew
Typewriter Poems. Finch, Peter (ed.)
How the Page Matters. Mak, Bonnie
First Screening. bpNichol
The Lo-Fi Manifesto. Stolley, Karl
Web Design Manifesto 2012. Zeldman, Jeffrey

Resources

Acknowledgements

This work was developed for and funded by the Jamie Cassels Undergraduate Research Awards program at the University of Victoria. This project would not have been as cool without the support and encouragement of Tim Lilburn and Karolinka Zuzalek, with special thanks to Patrick Close, Matthew Hooton, Megan Jones, David Leach, Courtney Løberg, Garth Martens, Helen Marzolf, Jordan Soles, Valerie Tenning, and UVic’s personal web space.

By “state,” I mean any three lines that you can see at once. ↩︎
This is a generalization about the literary culture in Victoria, British Columbia. I do not mean you any offence! ↩︎
I define games as objective- and choice-oriented systems, which are primarily unlike to the arts. I find nothing about gameness distasteful, but Sleep when exhausted is not intended to be a game. ↩︎
who deeply hates those awful slideshow-based articles and prefers to just scroll down a single webpage. ↩︎
For the JCURA installation, I presented the poem on an Asus Nexus 7 as a fullscreen application generated by Google Chrome. ↩︎
The Lo-Fi Manifesto. Stolley, Karl. ↩︎

backfilling my weblog?

2010-03-20T19:25:00-07:00

how do you feel about this idea? this is something i did today: i ported all of the reviews from my letterboxd account to my main weblog, here, on benjaminwil.info.

it’s something i’ll continue to think about: it kinda looks like i changed history, after all. that said… it is content that i wrote on those dates. i could add notes to the posts to contextualize? but my blog isn’t important or widely read anyway.