Now, the ideal way to deliver this content would be while wearing a fashionable suit, in front of a large pinboard of some kind, but this won’t work for me. Unfortunately, both my body and camera equipment are terrible, and I do not own a fashionable suit.

Unraveled, if you are not already familiar with it, is a now-defunct Polygon series, on YouTube, where, along with his helpful team, video producer Brian David Gilbert tackles a difficult, obscure video-game-adjacent topic, like “reading every single Halo novel and telling you about them” or “actively losing his mind over obscure details in the Sonic lore”.

There are 29 episodes of Unraveled, produced between the first episode on September 2018 and the last, two years later, on December 2020, at an approximate pace of one episode per month. I also have approximately one episode per month, although with therapy I might be able to get that number slightly down.

The first step in taking these 29 episodes and determining which one most closely fits the platonic ideal of an episode of Unraveled is creating a rubric which we can use to evaluate each episode.

We can start by identifying what really makes an episode of Unraveled so good:

Authoritativeness

In order for the humor to land properly, it’s important that whatever incredibly obscure topic the piece is covering is treated with the utmost gravitas. You don’t just want to know which Pokemon is the most edible - you want that information from a source that seems authoritative. You want the final word on Pokemon edibility.

Otherwise the topic could come off as frivolous, and we don’t want that.

A Topic of Interest Connected to a Popular Game or Franchise

The episodes are, of course, self contained and humorous enough that you’d enjoy them whatever the topic, but the reason you clicked on the episode in the first place was very basic and animal. It promised you Mega Man lore. You like Mega Man. I can say with some fairly concrete certainty that you like Mega Man because he fights a colorful rotating cast of fancifully themed opponents, and has an arm that’s also a gun - it goes “pew pew”.

Subtly Flawed Methodology

Now that the problem space has been introduced, the next step is to concoct a plan to attack that problem space - a rubric with which to evaluate the data.

Now, considering the difficulty and relative intractability of some of the projects taken on, it’s likely that no truly satisfying methodology could exist. That must be pushed aside in favor of something that’s possible for a human to do, and satisfying enough.

However, this is a comedy show, not a dry lecture series, so the methodology must be in-and-of-itself entertaining.

Foreshadowing and Call-Back

One crucial element of humor is that it is always in conversation with itself. One classic standby of comedic writing is the callback joke. There’s a set-up, and then the set-up is left hanging for a bit, ideally just long enough for you to forget it - only for it to be invoked again. Callback jokes can be re-invoked again and again, but they’re at their best when they give you enough time between the set-up and pay-off that you’re caught by surprise.

The subtly flawed methodology itself is a form of foreshadowing: if you can catch what the problem is with the rubric, you’ll be able to see the thread that, when pulled, will tease apart the whole plan.

Act 1: The Set-Up

Together, Respectability, Topic/Franchise, Methodology, and Foreshadowing constitute Act 1 - the Set-up.

We’ve established that Brian is an expert, what he plans to do - and how. With that out of the way, all he needs to do is execute the plan, and we’re set.

Act 2: The Execution

This is the part where the rubber meets the road. The meat of the episode: the reason we came here in the first place. Exhaustive data. Conspiracy boards. We’ve established the silly premise and the absurd lengths that BDG will go to fulfil that premise, and so we’re off to the races - and the more absurd the lengths are, the better the joke works.

This operates under the same logic as a virtuoso performance: it’s impressive to watch someone who’s mastered a difficult topic, but in this case it’s a virtuoso performance of Brian suffering under an avalanche of trivial data.

Act 3: The Twist

There comes a point in every Unraveled where the combination of data, flawed methodology, and meticulous execuction are starting to lean in the direction of an unorthodox or unsatisfying conclusion. Things started so well, but they’re going off the rails quickly - what was promised was that a complex topic would be unraveled but what’s quickly becoming clear is that it is the episode itself coming unraveled.

This is the twist, the turning point from which there is no return.

Finally, the Prestige

When all is lost, though, one final beat: victory is snatched from the jaws of defeat. Perhaps from an unexpected source.

This is a great time for a callback to whatever we were foreshadowing, earlier, if possible.

So these are our categories:

• Authoritativeness

• Topic Accessibility

• Methodology

• Foreshadowing/Callback

• Execution & Suffering

• Twist

• Recovery

So, in order to evaluate the Unraveled episodes, we simply need to take each of these qualities, and evaluate them on a scale from one to five stars. The best episodes will be the ones that score the highest.

Actually, just before we begin, let’s add one more category to the rubric:

Does Brian Sing? How Much?

BDG has got real theater kid energy, and that expresses itself constantly, through song. Who am I to deny this part of his persona?

Let’s Begin:

Solving the Zelda Timeline in 15 Minutes

• Authoritativeness: 5

• Topic Accessibility: 4

• Methodology: 3

• Foreshadowing/Callback: 3

• Execution & Suffering: 3

• Twist: 2

• Recovery: 3

• Does Brian Sing: 0

• Total: 23

A solid opening salvo, this one is the boring Mario of episodes, establishing the format and tone while not taking any big risks.

As the timeline dissolves into complete incoherence, the lights turn redder and redder.

The episode consistently foreshadows the mysterious details of the Time Break with the Twist being - well, the basic joke: this is getting ridiculous, and it doesn’t seem like it’s going to be possible to reconcile all of the different timelines and the Time Break near the end.

The recovery?

I read all 337 books in Skyrim so you don’t have to

• Authoritativeness: 5

• Topic Accessibility: 4

• Methodology: 4

• Foreshadowing/Callback: 0

• Execution & Suffering: 4

• Twist: 1

• Recovery: 0

• Does Brian Sing: 0

• Total: 19

This one’s played completely straight. Brian establishes a valid methodology, doesn’t get silly with it, and just executes the methodology as planned.

After establishing in the first episode that “unraveled” isn’t just about unraveling a deep or difficult lore, it’s also about unravelling Brian, this episode is just a straightforward lore deep-dive with no complications. Huh.

Ranking all 200+ Mega Man robots

• Authoritativeness: 5

• Topic Accessibility: 5

• Methodology: 4

• Foreshadowing/Callback: 0

• Execution & Suffering: 4

• Twist: 1

• Recovery: 0

• Does Brian Sing: 0

• Total: 20

Similar to the last one: Brian just identifies a topic and goes and makes a big old graph with it. It’s funny because the graph is big and this seems like a lot of work, but this Unraveled stays extremely well-raveled.

This one might be my actual favorite episode because I am a basic bitch and I just love me some Mega Man robots.

I wasted 3 weeks of my life finding Castlevania’s hottest monster

• Authoritativeness: 4

• Topic Accessibility: 5

• Methodology: 3

• Foreshadowing/Callback: 0

• Execution & Suffering: 3

• Twist: 0

• Recovery: 0

• Does Brian Sing: 0

• Total: 15

I’m deducting some points from this one because it’s pretty horny and it’s methodology feels even more entirely subjective. Good methodology moments include “cutting animals and humans out of the list”, but as we get further into the video the cuts include anything that would make the answer too obvious, which is a sign that the topic wasn’t very interesting in the first place.

The suffering in this one is palpable, but it’s referenced in a lost original cut of this episode which was apparently very comprehensive but also very boring.

Losing some authoritativeness, here, too, because the cravate is clearly intended to bridge the gap between “professional” and “lothario” and its success in that space is limited at best.

Smash Bros. owes millions of dollars in OSHA violations

• Authoritativeness: 5

• Topic Accessibility: 3

• Methodology: 4

• Foreshadowing/Callback: 0

• Execution & Suffering: 4

• Twist: 1

• Recovery: 0

• Does Brian Sing: 0

• Total: 16

This one suffers from the obvious problem: workplace safety, while it’s everyone’s job, is actually still very boring.

I’m going to give this one point of twist because it’s all revealed, at the end, to be a scheme to hit up Sakurai for $50.

Scientifically calculating the game of the year

• Authoritativeness: 4

• Topic Accessibility: 4

• Methodology: 4

• Foreshadowing/Callback: 2

• Execution & Suffering: 4

• Twist: 2

• Recovery: 1

• Does Brian Sing: 1

• Total: 22

Unfortunately, BDG’s weak understanding of math hurts his bonafides when he’s trying to build a formula, here.

Fortunately, that does constitute a twist: all of the effort that he spends building a formula ends up producing just terrible results - results that make his GOTY simply the game with the most Google hits. If you are following the math as he develops it you can probably suss out that this isn’t going to end well.

“Maybe I shouldn’t have made my mom’s knowledge of the game an exponential factor.”

This one also features a recovery: Fortnite may not be a satisfying GOTY, so the actual GOTY is whatever your GOTY is.

Every Sonic game is blasphemous

• Authoritativeness: 3

• Topic Accessibility: 3

• Methodology: 1

• Foreshadowing/Callback: 3

• Execution & Suffering: 3

• Twist: 5

• Recovery: 2

• Does Brian Sing: 0

• Total: 20

A truly well-balanced episode - although plagued by weak accessibility and methodology, this one has a stronger showing in the arc and callback elements.

Understanding Kingdom Hearts (and every other story)

• Authoritativeness: 5

• Topic Accessibility: 5

• Methodology: 4

• Foreshadowing/Callback: 1

• Execution & Suffering: 4

• Twist: 5

• Recovery: 1

• Does Brian Sing: 1

• Total: 26

Attempting to understand Kingdom Hearts through Joseph Campbell’s “Hero’s Journey” is as clever as it is cursed. There’s a moment of foreshadowing the first time that Brian goes through the loop where he “accidentally” lets slip how needlessly complicated and ornate Kingdom Heart’s backstory is, as a joke.

And wow, painless. A nice loop, Kingdom Hearts through the viewpoint of the monomyth. But then, the twist: as we start stacking more and more Kingdom Hearts games on top of the chart the chart gets more and more crazy and needlessly complicated, eventually necessitating a long string connecting the hero’s journey to a whole NEW hero’s journey loop, “the villain’s tridecagon”, which he had hidden behind a sheet.

Bowser’s military hierarchy

• Authoritativeness: 5

• Topic Accessibility: 3

• Methodology: 2

• Foreshadowing/Callback: 2

• Execution & Suffering: 2

• Twist: 1

• Recovery: 0

• Does Brian Sing: 5

• Total: 20

It’s just kinda Castlevania’s Sexiest Creatures again, with the same flaws: it feels arbitrary and the topic is pretty unsatisfying.

This one has a small twist: at the end we use Brian’s newfound knowledge of the Geneva convention to accuse Mario of war crimes! Which is… I don’t know, who cares?

On the other hand, a full 5 points in the Does Brian Sing category for “We Are the Toads”, a full “We Are the World” parody trying to draw attention to the plight of Bowser’s poor military.

Which Dark Souls boss is the best manager?

• Authoritativeness: 5

• Topic Accessibility: 0

• Methodology: 2

• Foreshadowing/Callback: 0

• Execution & Suffering: 3

• Twist: 1

• Recovery: 0

• Does Brian Sing: 0

• Total: 12

I’m giving this one a 0 for Accessibility because I don’t know what a “Dark Souls” is and I refuse to learn. This episode also attempts to analogize management style with “how fun it is to play against the monster in Dark Souls”.

IDK, it’s all over the place. Unclear! Muddy! Everybody just liked Dark Souls too much to go high-concept with this episode and instead they just kinda did free-form comedy about how each boss in the game would perform in an office situation.

No one asked but I found Mortal Kombat’s best cuddler

• Authoritativeness: 5

• Topic Accessibility: 4

• Methodology: 3

• Foreshadowing/Callback: 0

• Execution & Suffering: 3

• Twist: 0

• Recovery: 0

• Does Brian Sing: 3

• Total: 17

I bet you thought “Castlevania’s hottest monster” was going to be the horniest episode of Unraveled.

You thought wrong. It’s this one.

How to make a perfect E3 press conference (or drinking game)

• Authoritativeness: 5

• Topic Accessibility: 2

• Methodology: 5

• Foreshadowing/Callback: 5

• Execution & Suffering: 4

• Twist: 1

• Recovery: 0

• Does Brian Sing: 4

• Total: 17

The perfect E3 press conference is a relatively low-accessibility topic: an inside joke between gaming press and in-the-know gamers.

If what you’re looking for is set-up and callback jokes, this episode is an exemplar: both for its constant set-ups and callbacks within the episode and the much larger set-up and callback that is “setting up the final episode of the show”.

We made all 78 Breath of the Wild recipes in one day

• Authoritativeness: 2

• Topic Accessibility: 5

• Methodology: 3

• Foreshadowing/Callback: 1

• Execution & Suffering: 5

• Twist: 3

• Recovery: 0

• Does Brian Sing: 0

• Total: 19

There are some serious methodological weaknesses here and Brian spending most of the episode not in a suit and cooking very badly hurts his authoritativeness. The “in one day” makes it essentially impossible to do well.

Most of the food comes out sad and unappetizing.

It does rank highly for accessibility and suffering, though: I really want to see someone attempt all of these recipes, and Brian suffers mightily to try and provide this for us.

Good cooking content is hard. Do you know who could have done this topic justice? Joshua Weissman, who’s absolutely nailed the “cooking everything in a category” format. These videos look like they take weeks of effort.

Ultimately, this episode is entertaining, but it’s hardly an exemplar of the Unraveled format.

Calculate your pet’s HP with my 100% legitimate formula

• Authoritativeness: 3

• Topic Accessibility: 2

• Methodology: 4

• Foreshadowing/Callback: 0

• Execution & Suffering: 3

• Twist: 1

• Recovery: 0

• Does Brian Sing: 0

• Total: 19

Talking to real professionals always hurts Brian’s credibility. Yes I’m counting the cat as a real professional.

I fixed Fallout’s music by creating a totally new genre

• Authoritativeness: 5

• Topic Accessibility: 3

• Methodology: 4

• Foreshadowing/Callback: 3

• Execution & Suffering: 3

• Twist: 5

• Recovery: 0

• Does Brian Sing: 5

• Total: 28

The twist in this is so epic that I feel bad spoiling it here. Spoilers. Spoilers afoot.

After spending the entire episode foreshadowing it, Brian’s attempt to create the perfect music genre for the Fallout franchise ends up just… being Ska, Brian is just describing Ska, it’s been Ska the whole time.

I’m mad that this video did so well in my rubric. Maybe I shouldn’t have given so many points to “Does Brian Sing”.

Find your Kojima name with my simple 11-page form

• Authoritativeness: 4

• Topic Accessibility: 0

• Methodology: 5

• Foreshadowing/Callback: 2

• Execution & Suffering: 2

• Twist: 0

• Recovery: 0

• Does Brian Sing: 0

• Total: 13

Look, funny homework is still homework.

How to tell apart all 596 Fire Emblem characters

• Authoritativeness: 5

• Topic Accessibility: 3

• Methodology: 4

• Foreshadowing/Callback: 1

• Execution & Suffering: 4

• Twist: 5

• Recovery: 0

• Does Brian Sing: 1

• Total: 23

Dividing the many, many Fire Emblem characters into archetypes? Good methodology, fun execution.

The twist? The archetypes themselves can be combined into even fewer archetypes. Eventually Brian ends up with just the 1 archetype, having fully wasted his time.

I used The Sims to perfect my apartment

• Authoritativeness: 4

• Topic Accessibility: 5

• Methodology: 4

• Foreshadowing/Callback: 3

• Execution & Suffering: 4

• Twist: 4

• Recovery: 5

• Does Brian Sing: 0

• Total: 29

This has the strongest Recovery of any episode so far. Brian’s methodology is entertaining but it utterly fails. This episode has an arc! Brian learns a valuable life lesson! He doesn’t sing at all, though, so the episode is trash.

Waluigi, Unraveled

• Authoritativeness: 5

• Topic Accessibility: 4

• Methodology: 4

• Foreshadowing/Callback: 5

• Execution & Suffering: 4

• Twist: 5

• Recovery: 3

• Does Brian Sing: 0

• Total: 30

Imagine if you were to take " Every Sonic game is blasphemous" and do it much, much better. This episode is rich in foreshadowing as Brian gradually unveils his Waluigi similarities while building towards a dramatic moment where he realizes that he has been Luigi the whole time - and the episode constitutes a long-running meta-series lore joke as that mustache was a lot of work. Was this part of the plan since before the start of Season 2?

Kirby

• Authoritativeness: 5

• Topic Accessibility: 4

• Methodology: 2

• Foreshadowing/Callback: 3

• Execution & Suffering: 3

• Twist: 5

• Recovery: 3

• Does Brian Sing: 0

• Total: 25

High off of the arc of Waluigi, Unraveled, we have Kirby, where Brian is forced to go on a similar journey of the soul while faced with the impossibility of figuring out what the deal is with Kirby. This episode has some top tier unraveling in it.

Ultimately, though, the episode ends with Brian defeated. The aporia ending, with the unsatisfying conclusion that Kirby’s many paradoxes make him impossible, unknowable.

When can Mario retire?

• Authoritativeness: 3

• Topic Accessibility: 3

• Methodology: 0

• Foreshadowing/Callback: 0

• Execution & Suffering: 2

• Twist: 4

• Recovery: 0

• Does Brian Sing: 0

• Total: 13

Once again, Brian’s interaction with a professional robs him of authoritativeness, and once again, Brian’s weak math bonafides hurt the episode’s credibility and methodology.

The twist is that Brian screws up his math and some of his major assumptions and convinces himself that it’s impossible for himself or Mario to ever retire. It’s funny, but it’s bad financial advice. My wife watched this and it just fed her increasing fear that it would be impossible for her, a millenial, to ever retire.

How to increase your stamina with terrible video game tactics

• Authoritativeness: 2

• Topic Accessibility: 3

• Methodology: 2

• Foreshadowing/Callback: 1

• Execution & Suffering: 4

• Twist: 0

• Recovery: 2

• Does Brian Sing: 0

• Total: 14

This is another “weak methodology, humorous execution” episode. A lot of Brian’s time in this episode is also spent in a non-suit, sometimes while wearing clothing and accessories made of cardboard, which are a real hit to his authoritativeness.

I built the perfect gamer space

• Authoritativeness: 1

• Topic Accessibility: 1

• Methodology: 2

• Foreshadowing/Callback: 1

• Execution & Suffering: 2

• Twist: 4

• Recovery: 2

• Does Brian Sing: 0

• Total: 13

The Valorant tie-in reduces the accessibility and authoritativeness pretty badly here: I don’t care about Valorant. NOBODY cares about Valorant. It’s got interviews, the methodology is weak, the execution is awkward, and the twist is simply how weird BDG manages to get with his gamer space.

I read every Halo novel and became the Master Chief of loneliness

• Authoritativeness: 5

• Topic Accessibility: 5

• Methodology: 4

• Foreshadowing/Callback: 2

• Execution & Suffering: 7 (+2 BONUS SUFFERING)

• Twist: 4

• Recovery: 2

• Does Brian Sing: 0

• Total: 29

Oh boy, this is a strong episode, partially because the sheer sisyphean difficulty of the task that Brian took on here was just bananas. The episode has some arc, some callback jokes, a little bit of everything.

I made a '90s dimension to fully understand Crash Bandicoot

• Authoritativeness: 1

• Topic Accessibility: 1

• Methodology: 2

• Foreshadowing/Callback: 1

• Execution & Suffering: 2

• Twist: 4

• Recovery: 2

• Does Brian Sing: 0

• Total: 13

Another big hit to authoritativeness and accessibility from the sponsored episode.

I refuse to acknowledge that this episode is different from “I built the perfect gamer space” and will simply be giving it the exact same score.

We created the sport of the future

• Authoritativeness: 2

• Topic Accessibility: 2

• Methodology: 2

• Foreshadowing/Callback: 0

• Execution & Suffering: 2

• Twist: 1

• Recovery: 0

• Does Brian Sing: 0

• Total: 9

A fake letterman’s jacket is no authoritativeness substitute for a suit, and Brian spends a lot of this episode in shorts.

This is another episode marred by a weird concept and poor execution.

This was my pick for worst episode of Unraveled and I’m glad to see it also does very badly in the rubric that I invented.

Pokémon Edibility

• Authoritativeness: 5

• Topic Accessibility: 5

• Methodology: 4

• Foreshadowing/Callback: 3

• Execution & Suffering: 5

• Twist: 1

• Recovery: 4

• Does Brian Sing: 0

• Total: 27

After some of the weakest and strongest episodes of the series, we come to this, the final episode of the series. It’s a straightforward lore dive, like the ones that kicked off the series. A return to form - but with more of an arc, more emotional weight, than the previous lore dives. It’s a fine way to send off the series, and it was foreshadowed as far back as “How to make a perfect E3 press conference (or drinking game)”.

Our Victors!

With that, we can crown our champion!

“Waluigi, Unraveled” is the best episode of Unraveled, narrowly beating “I used The Sims to perfect my apartment” and “I read every Halo novel and became the Master Chief of loneliness”.

The worst episode is, unsurprisingly, “We created the sport of the future”.

Problems

Is it really Waluigi, Unraveled, though? I’ll admit, my rubric wasn’t perfect. I didn’t capture literally every single thing that I like about Unraveled episodes in my rubric.

Like, for example, I like it when Pat shows up. I like it when Brian does high kicks. It’s possible I’ve let my own bias colour these results far too much: there’s no way that you’re going to accept my own, personal ranking as the one truth.

I’m afraid that after going to all of this trouble I’ve … I’ve wasted my time. Your time. Everyone’s time.

There is no perfect Unraveled, obviously, so ultimately this is going to be a subjective endeavor.

Well, that’s disappointing. Well then. Thanks for … reading, everyone.

There Is No Perfect Unraveled

Huh.

You know what? There’s one episode I didn’t include.

A rare Unraveled, a live performance at PAX in 2019.

The Perfect PokéRap

This… this is promising. It has “perfect” right there in the name.

Authoritativeness

Nothing projects more authority than speaking in front of an audience. Brian isn’t just authoritative, he’s commanding.

So that’s an easy 5/5.

Topic Accessibility

Not only is Pokémon the third most popular video game franchise of all time, _I really want to hear Brian work on the PokéRap. This is compelling!

Okay, another 5/5.

Methodology

With more time than usual to develop his methodology, Brian can spend the entire first 20 minutes of his presentation laying out the methodology underlying his perfect PokéRap. It’s detailed. It’s informative. It’s precise. And, of course, just at the very end, it turns out to be subtly flawed because executing his perfect PokéRap would take longer than the amount of time remaining in his presentation block.

Well, that’s a 5/5.

Foreshadowing/Callback

Brian manages to maintain a number of running jokes throughout this presentation, including “Kevin Punt”, “Terry”, “Audience Participation”, and, of course, the set-up and delivery of the PokéRap itself. In fact, the “Audience Participation” turns out to be key to the eventual recovery.

That’s a 5/5, too.

Execution/Suffering

The Abridged Perfect PokéRap is, indeed, a virtuoso performance: at over 9 minutes long, it still manages to include over 400 Pokemon. While I might be over-estimating the difficulty of preparing and memorizing such a thing because I am not musical, I think that everyone found this impressive.

Another 5/5.

Twist

Obviously Brian got carried away with his plans for the True Perfect PokéRap, which became downright fanciful, and just as obviously it was going to be impossible to perform, bringing him to an end-of-Act-2 darkest before the dawn moment. This Unraveled unraveled and needed to be glued back together.

5/5.

Recovery

But there’s rescue from an unlikely source. A callback: Audience Participation. And this is a clever solution, too: Brian’s Abridged Perfect PokéRap does - sort of - contain every single Pokémon.

Does Brian Sing

You’re goddamn right he does.

5/5.

So there we have it. We’ve done it - we’ve found - not just the greatest episode of Unraveled: A perfect episode. We’ve done it. Science has done it.

there’s only one way to celebrate

I’ve been experimenting with storytelling tools for a while. That’s what my last post was about: storytelling tools and dialogue systems. That post was MONTHS ago. We’ve come a long way since then.

I’ve always wanted to make graphic novels, but, unfortunately, I have pretty mediocre art and writing and discipline skills: instead of becoming a better artist or writer, my plan is to simply wow people as best as I can with technological superiority.

And what I realized, eventually, was that I was … just kind-of building a Visual Novel engine.

After digging way in to Godot and building some node-based scene structures in there, with animated text and dialogue puppets, I was even more convinced: I think I really am building a Visual Novel engine.

So, given that, it was time to finally just go try RenPy. Seriously, there’s a well-liked tool for this kind of thing already.

Worst case scenario you learn a bunch of stuff.

And, you know what? RenPy had just about every feature I had wanted to build, already. It’s done. It’s a complete product. It lacks some of the high-end features I was building towards in Godot - namely: skinnable, animated puppets and text animations that are controllable down-to-the-letter - but it HAS features that I need and haven’t even started working on yet, like transition effects, menus, and conditional statements.

Neat.

So, my wife goes out of town to visit her mom. I stay home to take care of our cat - and in my boredom and loneliness I watch some old episodes of Columbo.

You know, because the recent show “Poker Face” was just Rian Johnson writing a love letter to old episodes of Columbo - after watching 10 episodes of Natasha Lyonna expertly pulling her imitation of the Peter Falk Shuffle, I just had to revisit the original.

I watched a lot of old episodes of Columbo. Behold this gigantic toot-stream of me just clowning on old Columbo episodes for hours.

As a result of learning about RenPy and shotgunning several consecutive episodes of Columbo, I make a little pledge to myself:

I’m going to make an episode of Columbo into a RenPy visual novel.

Now, at the time, July 11th, I figure “this is going to be easy”. No problem. Ezpz. I will be done in 2 weeks. (I honestly thought this: I am a fool. )

I did some basic experimentation with it: WASM web export seems to work fine, I could even run the WASM website on my phone, it seemed like a slam dunk.

This is another thing I’ve been doing lately, but I’ve been developing projects in the awful, awful 19.5 : 9 vertical aspect ratio of phones when I work on… any new project.

The idea is, I think, is that it presents an unpleasant but acceptable interface for web users, but pretty verifiably looks good on phones.

Now, finally, instead of endlessly building tools, it’s my responsibility to sit down and just grind out some damn content.

And… grind I did!

I learned the basics of RenPy and sat down to pump out a script. I based it very, very heavily off of “Death Lends a Hand”, a fan-favorite episode.

I also, almost immediately, wandered way, way off-script. Certain elements bear a passing similarity to Death Lends a Hand, but the final script ended up almost impossibly weirder.

“Detective Capilano”. I couldn’t just outright put actual TV character Columbo into my script, this is not fanfic, this is… serial-numbers-filed-off LEGIT fanfic, and so Detective Susan Capilano is named after - well, Joe Capilano, famous Squamish and namesake to many British Columbia landmarks and institutions. Sure, it may raise a lot of complicated questions to name a character after an indigenous leader, but in my defense, “Capilano” is very close, phonetically, to “Columbo”, while also being a tie-in to something that’s personally meaningful to me.

The final product also ended up… long. Quite long. Reading the entire script, end-to-end, took about 45 minutes, which would make my script about as long as an episode of Columbo. Just writing things took about two weeks. I thought I’d be done the whole project in two weeks, but no, that was just words. (Keep in mind, I have a day job that I’m quite good at, I get about 2 hours a day of Personal Project Time, so, maybe 28 hours total for the full script.)

After the script it came time for sound. Most of the SFX design just came from the eternally useful freesound.org , but I was struggling to find a collection of truly usable free, soundtrack-appropriate, royalty free music - until I bumped into the collection at incompetech.com, which was absolutely sufficient to the project I was trying to build. Not perfect - I would LOVE to be able to compose my own music, but it’s not a skill I have in the tank, and I’m not going to commission a musician with real money when the stakes are a free RenPy game, that’s a bad life decision.

Sound went relatively quickly.

Then, finally, art. Ho, boy. I kept this story dirt simple: maybe 6 major locations and 10 named characters.

Scene backdrops were prepared in chalk outline on a black background: this scratchy, lo-fi background can be completed very quickly, and I think looks distinctive.

Even with the obvious simplicity of the art style, I cooked up about 30 of these, maybe 3 an hour, for 10 hours, which (remembering I have about 2 hours a day to work on this) ate another whole week.

And that brings us to the final phase, character art.

I had been looking forward to this for weeks. And… after finishing my first few shots, it turned into as much of a slog as the rest of the project. I didn’t want to do the “baby’s first VN” move of just having a handful of cards per character - I wanted to do some acting, especially with our main character, Detective Capilano.

I ended up with 79, count-em, SEVENTY NINE poses for Detective Capilano.

To be honest, the whole story bounces through about 7-8 main Capilano poses, like “attentively listening while holding a notepad” and “hmmmm” which amount to about 75% of any given detective’s milieu, but then sometimes I’d need a really, really specific pose to make a joke land or to tell some of the story visually.

Like, this happens exactly once, in the story, but it’s an IMPORTANT SNIFF:

Most of the other characters have 8-12 poses, and I also included images for all of the 23 collectible items in the game, for a total of about 200 separate units of character art.

Again, even at the prodigious and lazy pace that I generate art, that’s a lot of raw ART asset, and it took me about 3 weeks to power through that big pile of art assets.

And then… I was done!

I mean, sure, there’s probably an aggressive polish pass I can do on this game, but it’s a visual novel I slapped together in a hurry: it’s not going to magically turn into a viable product with a huge userbase. You couldn’t pay most people to interact with a visual novel. I’m pretty happy with it, where it is.

Finally, it came time to give it its final name:

It’s completely playable, here.

And the launch was ready: I announced the game on Mastodon, on Twitter, and of course in the #side-projects channel at work. That’s about as big a launch as I can muster.

As a result, as many as… let me check my CDN analytics… 20 people played the game. (The numbers are up, it was 17 people, yesterday!) Oh, and because assets are downloaded as you go, I can also see how far each of those players got. Exactly one person has made it to the end.

If you’re curious what working this hard on a project and having just the one person finish it feels like, it’s not great.

I wasn’t expecting a lot of reception for a visual novel - generally they’re quite unpopular and amateurish. You can’t pay people to play them. It’s like asking someone to play your RPG Maker game, or read your unpublished novel: they’re not doing it because it’s going to be good. At best they’re doing it as a favor to you.

Even so, though, I was surprised at how emotional I was to ship something, again, that nobody really gave a shit about. I do this pretty often: ship half-baked, barely operational projects with zero marketing and no word of mouth, then look at my big ol’ bowl of Nobody Gives a Shit and cry literal actual tears for a few hours.

Just making things randomly and refusing to polish or market them, but hoping to receive a lot of attention and acclaim - my head understands this is a bad strategy, but I don’t fully understand it in my heart.

But, like always, I got over it in about a day. Being done with this frees me up to work on my next stupid thing!

Anyways, it’s out there, now! It’s released! I can still drive traffic to it, it gets to keep being a thing I built, and it’s going to stay online for years and years because, unlike some of my more ambitious projects, it costs me essentially nothing to host.

It’s just part of the Cube Drone archives, now!

Learning!

So, I have interesting takeaways.

WASM Considered Harmful

One of the first ones is that you can’t really target mobile device browsers with WebAssembly applications reliably. One of the things I’ve been trying to accomplish with these projects is to get something running that I can just give people an iPhone link to, and have it load and work seamlessly without having to go through any app stores or verification processes. Both Godot and RenPy offer WebAssembly builds of their product, and both Godot and RenPy have big, nasty, gamebreaking bugs on iOS, that I didn’t discover until I was already working with them.

Godot 4.0 has more than one, right now, most of them which the team have determined are upstream iOS problems that they can’t easily fix. The Godot 4.0 problems, though, at least had the decency to prevent the application from loading at all.

RenPy simply allows players to get about a third of the way through the game and then collapses with an out-of-memory error. This is very bad, and I didn’t catch it in my early prototyping phase. How could I? Toy projects didn’t use enough RAM to crash the browser. And now that I know that can and will happen, well, I expect it’s pretty likely to happen in Godot, as well, if I give it a sufficiently complex project.

I don’t have an Android device to test with but I imagine it wouldn’t be great, either.

This article, WebAssembly needs a better memory management story, goes into some of the reasons why trying to fit WASM apps into browser memory is currently something of a shit-show.

So, that’s unfortunate. With RenPy broken on iOS mobile, my game’s intended phone-sized form factor doesn’t serve nearly as much of a purpose. I mean, I could pay $99/year to get it on the App Store, but… I’m not going to do that for a free visual novel. The economics of paying Apple so that I can give unpopular applications away for free just doesn’t work out for me.

In fact, if I want things to execute reliably in all contexts, I think the choice is obvious: I need to go back to good ol’ Javascript in the browser. This brief flirtation with game engines was fun, but if what I want is for people to jump in with links, I’ve gotta go more lo-fi.

My Fiction Writing: Only Okay

I’ve been staring at this game non-stop for weeks, so I’ve lost all objectivity, but I think the low clearance rate speaks to the fact that this detective story can really draaaag.

I made sure that it works, mechanically, as a detective story: you, a reasonable human being, should be able to solve the thing, with the clues given. I like that.

I also packed this game with stupid jokes and even dumber film and music references. I like that too.

A lot of the bones, though, of good fiction writing - motivation, character, compelling scenes with high stakes - well, I know what those things ARE and I try my best to deliver on them, but I think this story could have stood to be half as long and twice as tight.

Which actually, brings me to my next point:

45-60 Minutes is Too Long

A 45-minute-long story is much, much too long. Most of the people who visited Detective Capilano’s website looked at the description, read “45 minute to 1 hour visual novel with SOUND”, thought “I can’t read that on the bus”, and bailed immediately, and I understand. That’s too LONG. I don’t want to commit to a 45-minute-long anything, unless I know it’s going to be worth my time.

On top of that, the sheer length of it made every part of its production drag on, and on, and on, and on. I basically cooked up a teeny tiny little community theatre play under my own power.

The story also has very limited interactivity, and no gameplay - partially because it’s hard to make a story this long with actual branching paths.

What I want is nice, tight, 5-minute experiences. Easy to build, with a small brain-burner of a real, actual puzzle in each one. Now that’s something I might be able to get people to sink their teeth in to, and something where I might be able to turn around the whole product on a tighter timeline.

I read a little blog post, a while ago, that made the point that indie creators who are looking to experiment wildly, polish their skillset, and learn to ship reliably should consider making Way More, Complete, Very Short Games, and I took that to heart - but I’m still making the games too big.

I Didn’t Need That Many RenPy Features, Actually

RenPy is a very powerful engine! With RenPy and plugins, it’s possible to build a lot of interesting stuff!

But, uh, actually, to tell this particular story I only needed a small handful of features:

• show an image on a named layer (layer: “detective” image: “hello”)

• hide a named layer (hide “detective”)

• play sound effect or music on a sound channel (channel: “music”, “farts.mp3”), maybe looping

• stop the sound or music on that channel

• animated text

• control over the font and color

• basic, baaaasic scene transitions

• screen-shake

• create an animation out of a series of image layers

• the ability to jump from scene to scene

• boolean flags

• an integer or two

• the ability to do the above bits conditionally based on menu inputs and boolean flags

This is a tiny fraction of the full set of features available to users of RenPy - which has a whole complex animation language and UI library under the hood. In fact, these are all things I could pretty easily write, myself, in Godot, or even Javascript: the stuff I actually need from RenPy is a pretty small and manageable subset of features and functionality.

I’m Not 100% Sure What I’m Building Next

I have a whole notepad full of ideas, as usual, but we’ll see. WE’LL SEE.

Finally:

If you have 45 minutes to kill, headphones, and are curious, try the game, here. If you want, write a long report of all of your thoughts and feelings and send it to me: I will read every word. Play it with a friend and voice the parts, and record it for the whole internet. Get weird. Play it for two minutes, get bored, and quit. Do whatever you like!

If you’re sitting at a PC, you’ll probably have a slightly better experience if you just download the PC build rather than trying to play it on the web - every image loads instantly rather than getting pulled from the CDN, it shaves milliseconds off your play-through time and feels much smoother.

So, sometimes, in FooApplication, we need to extract some Nurble Data from the HTTP request, which is included as a base-64-encoded JSON blob in a cookie from the Nurble provider.

/* extract nurbleData from the HTTP request */
function getNurbleData(request){ 
    let nurbleKey = `nurble_${NURBLE_API_KEY}`;
    if(request.cookies[nurbleKey]){
        /* nurble data is base64 encoded JSON */
        return JSON.parse(atob(request.cookies[nurbleKey]));
    }
}

Look at this function! It’s awful! Let’s do ENGINEERING to it!

First of all, what if there’s a parsing error? Are we just going to bubble that up and let it get caught by our normal error handling machinery? Hell no!

/* extract nurbleData from the HTTP request */
function getNurbleData(request){ 
    let nurbleKey = `nurble_${NURBLE_API_KEY}`;
    if(request.cookies[nurbleKey]){
        /* nurble data is base64 encoded JSON */
        try{
            return JSON.parse(atob(request.cookies[nurbleKey]));
        }
        catch(err){
            console.error(`getNurbleData couldn't parse 
                           nurble cookie: ${request.cookies[nurbleKey]}`);
        }
        
    }
}

Then, that nurble key prefix! What happens if it changes? We could be left editing code directly when we could simply adjust a constant! MAGIC VALUES BAD, YOU GUYS.

/* extract nurbleData from the HTTP request */
const NURBLE_KEY_PREFIX = "nurble_";
const NURBLE_KEY = `${NURBLE_KEY_PREFIX}_${NURBLE_API_KEY}`;
function getNurbleData(request){ 
    if(request.cookies[NURBLE_KEY]){
        /* nurble data is base64 encoded JSON */
        try{
            return JSON.parse(atob(request.cookies[NURBLE_KEY]));
        }
        catch(err){
            console.error(`getNurbleData couldn't parse 
                           nurble cookie: ${request.cookies[NURBLE_KEY]}`);
        }
    }
}

Here’s a thing, though - what happens if I call getNurbleData twice in a row. Am I just going to inefficiently parse JSON two times? That’s so wasteful. Let’s save the result of this function against the request in case we need it again later.

/* extract nurbleData from the HTTP request */
const NURBLE_KEY_PREFIX = "nurble_";
const NURBLE_KEY = `${NURBLE_KEY_PREFIX}_${NURBLE_API_KEY}`;
function getNurbleData(request){ 
    if(request.nurbleData){
        return nurbleData;
    }
    if(request.cookies[NURBLE_KEY]){
        /* nurble data is base64 encoded JSON */
        try{
            let nurbleData = JSON.parse(atob(request.cookies[NURBLE_KEY]));
            request.nurbleData = nurbleData;
            return nurbleData;
        }
        catch(err){
            console.error(`getNurbleData couldn't parse 
                           nurble cookie: ${request.cookies[NURBLE_KEY]}`);
        }
    }
}

Oh, that’s pretty sweet, but now we’re returning data from two different places in the code. Everybody knows that’s asking for trouble, better refactor it so that there’s just one return, at the end.

/* extract nurbleData from the HTTP request */
const NURBLE_KEY_PREFIX = "nurble_";
const NURBLE_KEY = `${NURBLE_KEY_PREFIX}_${NURBLE_API_KEY}`;
function getNurbleData(request){ 
    let nurbleData = null;
    if(request.nurbleData){
        nurbleData = request.nurbleData;
    }
    else if(request.cookies[NURBLE_KEY]){
        /* nurble data is base64 encoded JSON */
        try{
            nurbleData = JSON.parse(atob(request.cookies[NURBLE_KEY]));
            request.nurbleData = nurbleData;
            
        }
        catch(err){
            console.error(`getNurbleData couldn't parse 
                           nurble cookie: ${request.cookies[NURBLE_KEY]}`);
        }
    }
    return nurbleData;
}

That’s good, but that atob to parse in there is kinda complicated, let’s extract that and make it a separate function.

/* extract nurbleData from the HTTP request */
const NURBLE_KEY_PREFIX = "nurble_";
const NURBLE_KEY = `${NURBLE_KEY_PREFIX}_${NURBLE_API_KEY}`;
function getNurbleData(request){ 
    let nurbleData = null;
    if(request.nurbleData){
        nurbleData = request.nurbleData;
    }
    else if(request.cookies[NURBLE_KEY]){
        try{
            function parseNurbleCookieData(s){
                /* nurble data is base64 encoded JSON */
                let b = Buffer.from(s, 'base64');
                let o = JSON.parse(b);
                return o;
            }
            nurbleData = parseNurbleCookieData(request.cookies[NURBLE_KEY]);
            request.nurbleData = nurbleData;
        }
        catch(err){
            console.error(`getNurbleData couldn't parse 
                           nurble cookie: ${request.cookies[NURBLE_KEY]}`);
        }
    }
    return nurbleData;
}

Mmm, now we’re cooking with good engineering. But what if some other function also needs to parse nurble cookie data? We can’t keep that as an inline function!

function parseNurbleCookieData(s){
    /* nurble data is base64 encoded JSON */
    let b = Buffer.from(s, 'base64');
    let o = JSON.parse(b);
    return o;
}

/* extract nurbleData from the HTTP request */
const NURBLE_KEY_PREFIX = "nurble_";
const NURBLE_KEY = `${NURBLE_KEY_PREFIX}_${NURBLE_API_KEY}`;
function getNurbleData(request){ 
    let nurbleData = null;
    if(request.nurbleData){
        nurbleData = request.nurbleData;
    }
    else if(request.cookies[NURBLE_KEY]){
        try{
            nurbleData = parseNurbleCookieData(request.cookies[NURBLE_KEY]);
            request.nurbleData = nurbleData;
        }
        catch(err){
            console.error(`getNurbleData couldn't parse 
                           nurble cookie: ${request.cookies[NURBLE_KEY]}`);
        }
    }
    return nurbleData;
}

That parseNurbleCookieData function’s comment isn’t necessary any more, it’s all there in the title - but we could improve the comments in a few other parts of this function.

function parseNurbleCookieData(s){
    let b = Buffer.from(s, 'base64');
    let o = JSON.parse(b);
    return o;
}

/** 
 * Sometimes Nurble will include nurbleData with the request cookie.
 * for example: nurble_983277382237=bGlnaHQgd29yaw...
*  We need this data to nurbleize the normandifferentiator.
* 
*  memoizes nurble data in the request, for easier lookup
*/
const NURBLE_KEY_PREFIX = "nurble_";
const NURBLE_KEY = `${NURBLE_KEY_PREFIX}_${NURBLE_API_KEY}`;
function getNurbleData(request){ 
    let nurbleData = null;
    if(request.nurbleData){
        nurbleData = request.nurbleData;
    }
    else if(request.cookies[NURBLE_KEY]){
        try{
            nurbleData = parseNurbleCookieData(request.cookies[NURBLE_KEY]);
            request.nurbleData = nurbleData;
        }
        catch(err){
            console.error(`getNurbleData couldn't parse 
                           nurble cookie: ${request.cookies[NURBLE_KEY]}`);
        }
    }
    return nurbleData;
}

oh, and those other bits are constants and utility functions, let’s hide them somewhere else in the application:

// CONSTANTS/nurble.js
const NURBLE_KEY_PREFIX = "nurble_";
const NURBLE_KEY = `${NURBLE_KEY_PREFIX}_${NURBLE_API_KEY}`;

// common/nurbleParser.js
function parseNurbleCookieData(s){
    /* nurble data is base64 encoded JSON */
    let b = Buffer.from(s, 'base64');
    let o = JSON.parse(b);
    return o;
}

// nurble.js
const {NURBLE_KEY_PREFIX, NURBLE_KEY} = require('../../CONSTANTS/nurble.js');
const {parseNurbleCookieData} = require('../../common/nurbleParser.js');

/** 
 * Sometimes Nurble will include nurbleData with the request cookie.
 * for example: nurble_983277382237=bGlnaHQgd29yaw...
*  We need this data to nurbleize the normandifferentiator.
* 
*  memoizes nurble data in the request, for easier lookup
*/
function getNurbleData(request){ 
    let nurbleData = null;
    if(request.nurbleData){
        nurbleData = request.nurbleData;
    }
    else if(request.cookies[NURBLE_KEY]){
        try{
            nurbleData = parseNurbleCookieData(request.cookies[NURBLE_KEY]);
            request.nurbleData = nurbleData;
        }
        catch(err){
            console.error(`getNurbleData couldn't parse 
                           nurble cookie: ${request.cookies[NURBLE_KEY]}`);
        }
    }
    return nurbleData;
}

Mmm. Yeah. Can you feel it? Can you feel the engineering? This code is getting so tight and refactored. The power. The AWESOME POWER OF MY ENGINEERING SKILL IS UNMATCHED.

Worse… or Better?

Okay, so, I’m going to come clean. I am being flippant and sarcastic, here.

We have very clearly made our getNurbleData function quite a bit worse, right?

We’ve taken a simple, clear, easy-to-understand function and bloated it with unnecessary features, weird suppositions about the future, and wild overengineering.

We’ve taken valid errors and hidden them in logs.

We’ve added a memoization feature that nobody asked for, to save fractions of a millisecond of parsing time in the unlikely event that two different functions in the same request stack both need nurble data at the same time and don’t just save the original nurble data.

We’ve committed an act of Ravioli Coding, one of the lesser known software pasta sins, where we break simple, understandable functions down into teeny tiny little pieces and scatter those pieces to the four winds, even if nobody else needs those pieces for anything. We’ve taken important context and hidden it far away from the function that needs that context.

And, in fact, everything we’ve done to the function has been a good idea or best practice. There are lots of legitimate reasons to use the techniques I outlined here for good, it’s just that they can become an antipattern when applied unnecessarily and automatically.

In fact, me and another senior engineer spend a lot of our refactoring time taking code that looks like the end result of this process and de-refactoring it - peeling away “good engineering ideas” in successive layers, like an onion, until the code is once again simple.

DRY is less important than WET, YAGNI, KISS

“Everyone knows that debugging is twice as hard as writing a program in the first place. So if you’re as clever as you can be when you write it, how will you ever debug it?” - Brian Kernighan

“DRY”, “Don’t Repeat Yourself”, is a core engineering instinct. Do not ever write code twice, because you can always, always build an abstraction that allows you not to do that.

Too-aggressive application of DRY, though, almost always results in just the gnarliest code.

0 -> I

1 -> Is

2 -> If

3 -> To

4 -> Like

5 -> This

6 -> Efficiency

7 -> Improve

8 -> Talked

9 -> Imagine

4, 9 2 0 8 4 5 3 7 6

Look at how neatly I refactored that sentence! Using reusable, composable functions! Toss in some parens and I’m a Lisp programmer.

But … consider self-similarity, consistency, simplicity, readability. Boilerplate good actually.

Enterprise Hello World

This is just one function - if you apply this kind of aggressive ENGINEER THINKING to an entire library, you end up with ENGINEER CODE. It’s modular! It’s functional! It’s composable! It’s modifiable! It’s…

It’s Enterprise Hello World:

There are a lot of antipatterns out there but this is one of the ones that I see most often, because - well, we’re surrounded by good engineers with extremely high tolerance for complexity and abstraction, and they just want to take their good code and make it into really good code. They want to foresee every possible use of their function and have an answer prepared.

Databases end up over-normalized. Machinery ends up tying things to config values that don’t need to be configured.

“Am I so out of touch with modern engineering practices?”

“No, this code did not need to be this complicated.”

“What if I want to show people the stuff I’m working on, like, quickly?”

So, over the weekend I connected some Godot code to a CI Pipeline: whenever I push a build, it builds a WASM+OpenGL build to a Wasabi (cheap S3 clone) bucket, at which point I can just serve the bucket from a web endpoint.

That’s a first step in a more complete build pipeline: asking people to fish through an empty indexed directory is not a Final Product kind of thing, but from here I can kick off an Eleventy (think jekyll) build or something to build the rest of the website around the engine. (in fact, I’m also thinking of replacing THIS blog with “Github Actions” + “Eleventy”, because who trusts substack? Not me!)

Now instead of showing people short videos, I can literally pass around the entire game as an example. Still… still probably going to use short videos, though.

This CI/Web process has turned out to be fraught with danger.

First of all: I’ve been doing all of my learning in Godot 4.0, which is blisteringly new. A new beta or RC has been shipping week after week; It’s a fairly large rewrite of Godot, and while it has all the new features it’s also rich with jank.

While the web build ran on my computer when I first tried it, the compiled WASM took up 45MB, which is hardly heartening for a web project where sizes over 1MB for a website are still considered a little rude.

It wasn’t until I had the whole web pipeline was up and running, though, that I got to see how the 4.0 web build would perform on an iPhone or a mac desktop: very, very poorly. I think something about the interaction between WASM, OpenGL3, and ARM has gone very wrong, here, because while it loads sluggishly (a few seconds) on a PC, it takes something like 90 seconds to load on a Mac (technically that’s not broken, but it’s broken), and doesn’t load at all on an iPhone.

I spent many hours poking at this in forums, documentation, GitHub issues, but the whole system is so new in Godot 4.0 that finding any information about it is difficult. Godot 4.0 supports multiple renderer backends, but OpenGL 3.0 is one of its most limited, and for pressed as to why Godot’s web experience is terrible the developers have long responded with “it’s not really for that”. Godot-for-web is a bit of a second-class experience, so Godot 4.0 not working quite right on the web doesn’t feel like it’s going to be a huge priority.

That being said, I never bothered to file an actual bug: maybe I should! I’m an awful open source citizen, you guys: I tend to interact with projects in read-only fashion like they are unmaintained wastelands and fork-and-patch if I need something changed rather than attempt to communicate with a human.

Anyways, I decided to try a Plan B: how does the web build work with the previous major version of Godot? I remember I’d tried it before and it worked okay! (In fact, at Godot 4.0 beta 1 there was no web build at all, they kinda “remembered” and it’s been jumping in and out of the product in various states of half-broken ever since, whereas Godot 3.4.1 has been stably chugging along for months.)

When I’m starting new projects, I like to chase the bleeding edge of the tech somewhat - it makes learning harder because everything is actively on fire, but it also means that I’m slightly less obsolete in a few years.

Anyways: it works pretty well. Godot 3.4.1 offers the ability to compile for OpenGL 2.0, which is an older standard that’s more well-supported across browsers.

The compiled output is much smaller, too: about half of the size of Godot 4.0’s web build. Still 14Mb, but after applying aggressive gzip compression at the CDN level it ends up shipping to the browser in a relatively svelte 4.5MB. That’s still a big boy, but it loads quickly enough that I wouldn’t be embarrassed to ship it to production (I believe that weighs in smaller than our compiled VRChat Web Application build, although this 4.5MB is without any external assets)

It runs seamlessly on my computer, on my mac, even on my iPhone:
https://cardchapter.com/v2/web-2023-02-15T07%3A59%3A23.393Z/

That’s a surprise, too: the Godot developers rightfully warn you from trying to get any kind of web game running on an iPhone, because WebKit’s WebGL support is complete and utter horsetrash. On purpose. Apple wants you to run iOS applications. Their support for running in-browser WebGL is described as, uh, experimental/janky. But, at least for the basic tests I’m running right now, 3.4.1 compiles and runs a web build that boots up.

Converting this batch of code to run on 3.4.1 does take some effort, though. A lot of changes have been made since 4.0 and projects do not backport cleanly. For one thing, I have to go back to the awkward python-inspired yield instead of the much nicer async/await.

On top of that, I lost some viewport flexibility.

But overall, it seems to work! And while I was here, I got the oh-hai HiDPI settings working - this looks crisp on an iPhone or my UHD screen.

And, hey, now that I’m back in a well-supported version of Godot, there’s a much more comprehensive community of working plugins.

I still have the whole pipeline available for 4.0, so I can keep the possibility of porting forward on the table for now.

Tirelessly Reinventing the Wheel

(this title is a pun, because a tire is a kind of wheel)

Okay, so, what’s actually happening in these demos? It seems to be just a bunch of camera moves. That’s barely anything!

Well, yes! I’m trying to figure out the camera.

The current build has three targets, which it moves between with the camera:

There’s both “code” and “no code” - the whole thing is held together by these modular command nodes in Series, like “Delay”, “Appear”, “Play”, and “CameraMove” - so I can build out the entire scene with clicks and drags, rather than having to fuss around with code.

It works pretty well! The plan at the moment is to add Dialogue nodes (folding in all of the work I’ve been doing recently on that ) - and “Nav” nodes (to build a navigational structure so that the player can move back and forth within the story), and “Lock” nodes (with challenges that the player has to overcome to continue), and so on and so forth.

Ultimately where that puts the system makes it feel almost closer to being a … Visual Novel Engine. Huh. Maybe I should tool around a bit with Ren’Py or VN Maker and see what they have to offer.

I kinda realized that what I was building here was kind of an updated version of my CardChapter tree-based narrative/presentation system so the engine is being rebranded as CardChapter 2, until I … you know, change my mind again, two weeks from now.

So that’s one way in which I’m reinventing the wheel: CardChapter is literally a wheel I’ve already invented!

I don’t talk about it that much any more, but it was built to be a mobile-friendly long-form narrative engine supporting modular node-based content. It’s totally static - CardChapter documents contain both their own data and all of the code necessary to interpret that data - and the tools for modifying CardChapter documents are all contained within the CardChapter engine itself, so every CardChapter page is just the entire engine, which means that any document can be used as the locus for a new project.

And… like, CardChapter is weird! I get it! I rebuilt my entire comic website to use it, and people mostly just complain about how it’s “unsearchable” and “hard to find things in” and “awkward” and “weird” and “doesn’t support RSS”.

I mean, it would require a complete ground-up rewrite - modern search engines are Not Your Friend anyways.

(my glory days of actually running a comic website were with Django: my custom Django engine was actually very usable, IMO)

I got at least some of the way through a story using CardChapter: northwestica - but the story was built using an older build that still had pretty bad “flicker” issues. That being said: I’m pretty proud of the work I did there. Nobody read it, but northwestica was funnier than cube drone IMO.

I built a christmas quiz for my family to run over Zoom for a very sad 2020 family gathering with it, and a sequel, Family Day Quiz.

Mostly, though - and I partially blame its idiosyncratic quine-based structure and single-document architecture for this - it never really crawled all the way out of jank valley. Do you know what presenters want? It’s not tree-shaped documents and functional quines.

But this story about reinventing the wheel, while it could be about my tireless and almost entirely cursed attempts to re-build comic hosting a full decade after webcomics have ceased to be a relevant medium wasn’t even what I came here to talk about!

Tirelessly Reinventing the Wheel pt 2: Learning What a Tween Is

Instead: when I was working on those camera moves, I made a little node called AnimationHelper to help run all of the interpolation math required to do animation properly. It’ll do a nice little bounce for me if I want. It’s got three entire easings, "linear", "cubic", and "bounce".

Then, while I was watching YouTube videos about popular Godot plugins, it talked about Anima, a more powerful plugin replacement for the built-in Godot Tween class.

The fuck is Godot’s Tween class?

Godot: Tween

… oh, look, a little helper function to run interpolation for me.

I guess, on one hand, I feel like a schmuck for building this myself out of code when a tool already existed. Obviously a game engine is going to have a built-in interpolation library, right? In retrospect I should have looked for it rather than building my own. In my defense, though, I am really, really not a video game programmer.

On the other hand, like that one time a decade ago that I built my own little command-line tool to automate the creation and synchronization of local development virtual machines, only to discover a recently-developed tool that did that exact same thing, but way better: initial feeling, frustration, but after not too much introspection, not only am I delighted that this much more well-developed toolchain exists, I’m also happy that I understand it way, way better now. Fuck yeah, gonna go learn Anima.

“Build it yourself by accident, then discover the tool that does it way better and makes your job 1000% easier” is, in my experience, one of the better ways to learn things.

But, years ago, Tiffany asked me a question that has haunted me to this day.

How do you spell jujj?

Me: “Jujj?”

Tiff: “You know, like… I’m gonna jujj it up a little.”

Me: … I … don’t know! Jujj? Zhooj? Jooj? Juj? Jeugh? Geuge?

Then we were watching the Stupid Netflix Bartender Thing with the captions on, and someone says it. “Gonna jujj this drink up.”

And the captions person has spelled it … zhuzh. Huh. I’ve never seen that before.

I made Tiff pause the episode so that I could look at that spelling up close. ZHUZH. Zhuzh? zhuuuuuuuuzh.

Is this how the word is truly spelled? Is there finally an answer for me?! Why couldn’t I find this when Tiff first asked, many years ago?

First and foremost: there’s no English-language letter for “ʒ” ( ʒʊʒ ) so English works around it in words like uʒual, viʒion or garaʒ - which can be spelled a lot of ways, so there’s no really obvious grammatical spelling for zhuzh.

So I look it up and it seems like zhuzh is currently the accepted spelling of the word… but all of these articles are from 2018+. Is this word only a few years old? I’m sure I’ve heard it before that.

In fact, it would seem that… the various different possible spellings of zhuzh have been fighting for the past 20 years, and only recently has zhuzh started to pull ahead as the accepted spelling.

It seems like 2007-2010 was the turning point, where zhuzh started to take over.

One proposed origin for this term is originating from gay subculture in the 60s and 70s, and, in fact, it seems to have been geuge when written about back then:

Although this could be confounded by someone prominent or famous named, like, “Frank Geuge” or something - but a quick Wikipedia search turns up no Geuges.

For some reason, Google Search popularity only goes back to 2004 - I don’t know how they could be so sloppy with their recordkeeping.

Kick it up a notch.

Okay, another detail: Merriam Webster mentioned that the word “Zhuzh”, which made its debut on the “Words We’re Watching” list in 2018, was a popular catch-phrase of style icon Carson Kressley.

In fact, back in the Google Trends graph we can see that all of the various and sundry variants of the unspellable zhuzh were in full play in 2004-2008, back when Carson Kressley was on the air and people were trying to figure out how in the heck to spell zhuzh:

Carson Kressley claims to have learned it from Ralph Lauren, who spelled it “Zhoosh”.

Hey, there zhoosh is: dominating the literary world of zhuzhes even as zhuzh seems to be taking over as the dominant term. (Well after the dominant geuge of the 80’s.)

So there appear to have been at least a few major changeovers in the historied mystery of the word zhuzh: geuge to zhoosh between the 80’s and 90’s, zhoosh to nobody knows for sure in the 00’s, and then everyone finally settling on zhuzh in the late 10’s, around the time that Queer Eye’s reboot came on the air — all brought to us by a shady cabal of powerful lexicon-altering gay fashionistas who MAKE UP THEIR OWN RULES and ZHUZH WITH IMPUNITY.

Bright lights, neon, transhumanism, retro-tech, everyone knows that the future is a magenta-colored hexagon covered in advertisements, right?

Second Life - which functioned as both a metaverse and one of the world’s most wildly successful speculative real estate scams - really captured the feeling of being in a vast, open-air mall:

A lot of the future of virtual reality is in the hands of people who didn’t realize that Snow Crash was supposed to be a dystopian satire. This is the Ready Player One vision of VR as an exciting new place to purchase things.

And we lean into it a bit. Our art director is, for example, obscenely talented (but did you knoooooow) and has been known to show off work that fits the vibe:

The source material: Snow Crash, Neuromancer, Transmetropolitan, a bunch of high-tech low-life near-future stories intended to highlight the glittering inequality of a world where the only reins on technological development are “who can afford it”.

And yeah, we’re somewhat aware of this: a lot of digital ink is spilled on how to build social VR without becoming an abandoned virtual mall, a thinly-disguised child sweatshop, a slot-machine-inspired skinner box, a storefront without a game attached, or - even worse - doing all of the above while leaning in to the worst excesses of adtech and surveillance capitalism.

It’s important for us that people just enjoy being in VR, rather than participating in nothing more than a joyless exercise in an extractive marketplace.

So, while the idea of virtual reality is firmly rooted in the cyberpunk stories from which it came… the vision of VR as a casino or mall: a loud, cold, neon-heavy, visually busy, overwhelming, glittering Oasis intended to separate rubes from their money? That actually doesn’t appeal to people very much. It appeals to investors, but not… humans.

So, what do social VR spaces built by people actually look like?

These are some of the most popular worlds in Social VR. And these worlds are really, really popular.

Why, they’re not really very cyberpunky at all!

It would seem that our users didn’t get the memo about the aesthetic.

Heck, once you actually get into virtual reality, it seems like a lot of people don't want to inhabit a noisy glowing cyberpunk mega-bazaar, they actually want to inhabit THIS universe:

Coziness, VR's Secret Aesthetic

One time, on a trip up to Whistler, I grabbed a book in the one cute little bookstore and read it in its entirety in about one night. It was about hygge, a Danish word with extremely similar connotations to the word "cozy" but with more of a Scandinavian touch.

This whole concept was really trendy in 2016-ish.

On our trip, we visited a mountain spa called "Scandinave" where you pay a fixed fee to just hang out in a bunch of heated pools all day. While I was reading the book about Hygge, I realized that, uh, duh, Scandinave is also Scandinavian, thus the name, and they definitely 100% architectured this place with the principles of the book I'm currently reading in mind.

Which would seem like a fantastic coincidence except that - well, I bought the book in Whistler. These book-store owners know what's up.

Anyways, type "hygge" into google image search and you get this kind of thing:

A lot of us grew up in the Pacific Northwest (Oregon, Seattle, Vancouver) or in actual-Scandinavia and we know this aesthetic like we grew up with it, because we did.

Also you might notice that these images look a lot more like what people are actually building in virtual reality.

Why?

Because it's the furthest thing from cyberpunk. Rustic coziness of pools of contrast between dark and light. Roaring fires and rainy days and blankets and mugs of hot tea and cable-knit sweaters. Books and rugs and natural, unpretentious materials.

Cyberpunk is loud and crowded and impersonal, brand-names and tech-inspired-maximalism, blaring club music and bright lights - Cozy is small and intimate and cluttered and friendly.

Virtual reality, too, is loud and crowded and impersonal, overwhelming, too much noise, too fast. It comes at you quickly and it’s exhausting.

To quote one of my co-workers:

People want to socialize, public instances are not very pleasant for invested users with a built out friends list, and very full rooms are not enjoyable when our voice tech pumps every single ongoing conversation around you into your brain.

Public worlds are already too cyberpunk.

Introducing elements of cool and calm soften the rough edges around virtual reality's blaring and overwhelming nature and also naturally encourage the kinds of interactions that actually work best with the limitations of VR tech - small groups, intimate hangs, quiet chats.

As a result, the stuff we crave in virtual worlds look a lot more like what we see in the Scandinave: an organic grouping of small conversational circles connected by narrow paths, verticality and the ability to see other social groups from afar before engaging with them, zones of privacy, a fantastical backdrop, pools of light, warmth, and a sense of safety and security to offset the often bizaare and unsettling dreamlike quality of unfettered virtual reality.

Some of social VR’s most popular creators have realized this, and run with it.

And that, really, is the point I'm trying to make:

The dominant aesthetic of VR is not necessarily loud, crowded cyberpunk, but instead features a surprising number of quiet, thoughtful and chill spaces. This is a necessary adaptation to how flashy, cacophonous and obnoxious unfiltered virtual reality can be.

A lot of my stories start with “so I run into an image and it makes me think of something else”

SO, I was looking for an image to go with the idea of “windbag” and this comes up

“Oh! I know where that’s from! That’s a flame warrior! I … I wonder if that old website still works?”

Short answer: no, but there’s an Internet Archive page for it if you hunt around a bit.

Gosh, I sure am a sucker for archetypes.

Hey, Workspaces in Windows 11 are Kinda Good

I love Linux. And Windows. I love both Linux and Windows.

I’ve even liked the Windowses that nobody else liked like ME, Vista, and 8.

Anyways, I say this because Workspaces on Windows have been very gradually catching up to where Workspaces were in Linux in, like, 2008.

I can have separate pools for work and personal stuff, which is nice, and even have windows that show up in every workspace for stuff like VLC media player and KeePass that I just keep open all the time everywhere.

OpenAI is … helpful?

After spending a bunch of time trying to get OpenAI to do things it was programmed not to do:

This was legitimately a real question I had and was struggling to find the answer to on Google.

In fact, this image search for “small improvements” has resulted in what I would regard as an unusual amount of self-help hustle-porn. If you simply make yourself 1% better every single day, why, in 100 days you will be TWO ENTIRE PEOPLE. Think about that, why don’t you.

WORK SMARTER, NOT HARDER.

Anyways, I kind of remember this theory from a food video I watched a while back: a food-tuber, Alex, references the pop self-help book Atomic Habits, and uses it as a basis to try to improve his onion-chopping speed.

The central idea isn’t wrong, even, necessarily:

Big, obvious improvements can come with enormous productivity increases: if you’re bicycling on flat tires or chopping onions with a hammer, you’re going to see large, concrete productivity improvements from simply fixing the obvious thing.

But at high-levels - for example, bicycling competitions - or in skillsets where the baseline level of skill is high and the cost of high-end equipment is low - for example, onion chopping - most people have already exhausted all of the groundbreaking improvements.

So, instead, we start to seek improved performance by chasing a lot of little gains: if we make a bunch of little things a tiny bit faster, we’ll end up making the whole thing noticeably faster, right?

This is the underlying theory of a lot of speedrun world champions, too - watch them at GDC and they sweat every microscopic detail of the games they’re playing; even if there’s a whole minute they can lose to RNG, even if they’re playing for show in a marathon format rather than for a world record run, in order to stand a chance at all they need to be aware of every spot where they can skip 8 frames to save a fraction of a second. They add up.

Atomic Habits isn’t new, though; it’s a pop-self-help reframing of the Toyota business theory of Kaizen:

Kaizen

Kaizen (Japanese: 改善, "improvement") is a concept referring to business activities that continuously improve all functions and involve all employees from the CEO to the assembly line workers. Kaizen also applies to processes, such as purchasing and logistics, that cross organizational boundaries into the supply chain. It has been applied in healthcare, psychotherapy, life coaching, government, and banking. By improving standardized programs and processes, kaizen aims to eliminate waste and redun...

(ed: crikes, stealing ideas from Toyota was popular in the 90s, there are like three different major branches of modern productivity that are just “here’s what Toyota did in 1994” - you all know that we’re not all making subcompact sedans, right?)

Make small improvements regularly and things will speed up more and more. Eventually: fast!

… This all makes sense. The title of this article, “I Think Atomic Habits Might Be a Crock of Shit” is going to seem hyperbolic when I admit that I don’t have any quibbles with the core theory, here - small improvements stack up to amount to bigger improvements! Kaizen, as a business theory, is interesting to read about and more humanistic than one might expect for a theory about extracting Maximum Value From Humans: it is about empowering workers to improve their own processes by giving them freedom and flexibility to experiment with whatever makes them feel most productive.

Ultimately, when I fuss with our team’s CI or try to fix my keyboard macros just right, I, too, am engaging in a form of Kaizen.

Back to that original image, though:

This image doesn’t just promise small gains; this graph appears to offer a lot more: no loss in productivity, gains increasing in speed over time, and unlimited gains. It also does not bother to note the cost of these gains.

This is where, IMO, the “crock of shit” starts to intrude.

These micro-optimizations are supposed to be a way to extract microscopic improvements in a competition format, not a map towards a more healthy and productive life.

So what I’m going to argue is not the theory itself, but the implication that this theory is broadly applicable. I believe that these tiny gains often come with high cost, temporary loss of productivity, and badly diminishing returns.

The High Cost of Marginal Improvement In Both Time and Money

I love automating small tasks away. Sometimes I’ll spend days automating away a 2 minute task, because I know, deep down in my heart of hearts, that fussing with automation is more enjoyable than performing a boring ol’ 2 minute task, even if there’s no way I’m going to recoup the lost time I spent working on that automation.

These improvements are often extremely high effort and extremely low value - sometimes, for speed-runners, trimming a few frames out of each story window takes extremely precise and hard-to-trigger glitches that demand hours and hours and hours of practice. The time cost of this 1% gain in game performance is extremely high, and - if you’re comparing the seconds of your life spent on optimizing against the seconds of your life gained by that optimization, probably never pay off unless you are explicitly competing to the the fastest at the game in a competition format.

In Alex’s cutting experiments, he switches to an extremely high-end knife: a knife that may offer a tiny improvement in cutting speed in exchange for costing literal actual hundreds of dollars.

And that’s the things: once big, obvious improvements are out of the way, we’re left with the kind of improvements that people only care about when they’re chasing world class performance: you can make an absolutely banging cup of coffee with $50 worth of kit (plastic pourover, paper filter, blade grinder, basic kettle) - and then you can spend thousands of dollars and hundreds of hours chasing tiny, barely noticeable fine-grained improvements. (do you get the pun there? fine-grained improvements? because you’re going to tell me that burr grinder is better in the comments? that’s what I’m talking about)

I’m going to post a link to James Hoffmann’s YouTube channel here, it is absolutely fabulous to watch people go down these rabbit holes, but obviously attempting to apply these philosophies to literally everything in your life is insane, right?

Like, if you want to chase a 1% improvement in the sound from your grand piano, you’re looking at spending a mortgage-sized amount of money to chase that 1% improvement. This kind of thing literally only makes sense if you have already exhausted every other avenue of improvement and you’re in a position where that 1% improvement is tangibly worth that kind of money to you.

Learning colemak just might not be worth it, guys.

1% Maintenance Costs

On top of the lead-in cost to these many tiny 1% improvements, they come with ongoing maintenance costs:

In Alex’s Onion Chopping Mission, he took his already sharp knife and spent a little bit of extra time sharpening it extra, just before he started chopping onions, to get that perfect edge.

But, as anybody with good knives knows, keeping your knives sharp? That’s a forever job. While we could achieve optimal performance by performing a full sharpening before every single kitchen task, that performance would come at the cost of… an unnecessary and silly amount of time spent sharpening, and a much shorter lifespan on our very expensive knives.

That full sharpening for every task would also obviously take more time than it would save.

All Improvements Are Not Created Equal

Alex puts on “chef clothes” to improve his chopping performance and claims that it will have a psychological effect on his ability to chop.

Some pro-level improvements are just $350 audiophile-grade ethernet cables. They aren’t going to do anything and you’re fooling yourself if you think they are.

Some improvements that help 1% in one part of riding a bike will interfere with other improvements, or interfere with the development of other improvements.

An example from code: the oft-quoted “premature optimization is the root of all evil”. - or, the full Donald Knuth quote:

The real problem is that programmers have spent far too much time worrying about efficiency in the wrong places and at the wrong times; premature optimization is the root of all evil (or at least most of it) in programming

This is an oft-misunderstood quote: optimization itself is not evil, and this comes from a book where Donald Knuth has created his own personal insane hypothetical computer and shows you how to extract maximum performance from it.

I’m beginning to think that xkcd author Randall Monroe has thought about this more than I have.

The problem is that optimization - especially needless micro-optimization - is in-and-of-itself expensive and often makes the code uglier and harder to work with, which can get in the way of much more meaningful changes.

Everyone’s seen this ol’ gem:

Sure, it could mean that these two are too busy doing work to bother to try to improve their tools: an argument for kaizen!

But… these two could also be too distracted by micro-optimization of the wrong parts of their process to engage with… the big optimization, that they’re missing.

Sometimes big improvements will erase decades of micro-improvements: I imagine that “rolling” Tetris is sufficiently different from “hypertapping” Tetris that a lot of the micro-optimizations of one do not necessarily cleanly map to the other.

Competition cyclists really don’t have a lot of space for improvement: they already have the good bikes, the technique, everything down pat. For most people, that’s not the case. It’s really unlikely that a series of micro-optimizations to your bicycling regime will perform better than simply fixing your flat tire.

The point I’m trying to make here is that these reams of small improvements are the realm of professionals for a reason:

You Simply Can’t Be The Best at Everything

I can’t remember the exact talk, but I was at a game industry conference one time and I caught a talk where someone made a case that, in order to be successful, a video game company needs to be best-in-class at one or two extremely focused things and they need to be passably good at everything else.

Trying to chase the A+ performance in every possible direction at once is too expensive for any studio to chase - there’s not enough time or money in the world to make The Perfect Game and trying is how you get bloated Duke Nukem Forever-style disasters.

A company that can field one A+ with dozens of C-'s is going to be way more memorable to consumers than a company that gets a solid B in everything.

Also, as it turns out: just being mediocre but sufficient at a great many things is incredibly hard and a talent in its own right.

If you’ve heard of T-Shaped Skills as both a career development and hiring guideline: you want to be incredibly talented at one or two things, and broadly capable at a lot of other things.

Heck, that’s one of the things that I like about VRChat: we’re out there being the absolute, unrivaled king of one specific thing and I’m running around behind the scenes helping to be their C- in everything else.

My fucks Improvements Have Runneth Dry

On top of that, lo and behold, these Tiny Gains eventually run out. Eventually, every corner of the game is just so micro-optimized that there are no more tiny gains to be found.

Back to speedruns:

While people are still discovering big improvements for games, their speedrun time comes down dramatically. This is the “finding new techniques” (or “flat tires and onion hammers”) phase of speed-running - new discoveries are fresh on the ground and it seems like the players are posting impressive new times week after week.

Then, there are long plateaus where there are no new discoveries, and people are just Kaizen-ing their way through every moment of the game to shave off a few seconds here or there.

With all of the easy slam dunks out of the way, and even most of the small improvements exhausted, these players are now fighting over the last few fractions of a second. Of course, advances in speedruns continue, but I think it’s obvious, almost axiomatic, that chasing perfection has diminishing returns as you approach perfection.

So?

I’m going to admit it: I haven’t even read the book. Maybe if I dig in deep it’s going to be up-front about some of these downsides (pop self-help is usually very realistic and down to earth about how its advice isn’t entirely infallible, he says sarcastically) so, 100% of this post has been me making fun of that graph. Look at that graph! It’s terrible! Bad graph!

Sure, I believe that many small improvements can add up to make big improvements. Ultimately, though, I believe that a self-help theory of drowning your life in micro-optimizations misses the forest for the trees.

Stacking micro-optimizations can not be done forever, at low cost, with no loss in productivity, with guaranteed returns; on the contrary - a lot of the times micro-optimizations are expensive, fussy, needless, hard to maintain, and only really make sense if you’re chasing the top tiers of performance in any given field.

Mostly, I believe that books like Atomic Habits exist because they give you an excuse to feel less guilty about buying yourself some sweet pro-grade equipment for almost unnoticeable improvements in your life; they exist because hustle porn - the fetishization of productivity at any cost - always sells well.

They also might be a crock of shit.

Spaghetti code! It’s that thing where your code is bad and hard to follow.

I feel like spaghetti got the raw end of the stick here. Spaghetti is, according to science, delicious. People rarely encounter spaghetti and go “man, this spaghetti is hard to understand”

Nah, it’s easy to figure out spaghetti. You put a fork in there, twirl it around a little, then put the fork in your mouth. Spaghetti solved.

It’s term coined in the age of GOTOs: It was often possible with gotos to write code where following the code’s logic would feel literally like unwinding a big pile of spaghetti.

GOTOs, also, haven’t been common in code since decades before I was born. They got considered harmful so hard that they’re no longer part of the equation. “Spaghetti code” eventually grew to became a common term for any hard to follow code. Spaghetti code.

You monsters. Spaghetti didn’t deserve to become the gold standard term for bad code. Spaghetti is incredible. The term has lost all meaning.

You should go write some spaghetti code. Go write some code that everybody loves, that’s good with anything, that comes together in moments to solve quick weekday problems, code where you can just dig in anywhere and immediately understand how great it is.

Spaghetti does not need to be organized in a logical fashion! I doesn’t matter if you can or can not understand where every individual strand of spaghetti is coming from or where it is going. Nobody wants that from their sketti! You can start anywhere and end anywhere. THAT IS ALWAYS HOW EATING PASGHETTI HAS WORKED.

In fact, if someone did attempt to take their spaghetti and tidily organize it before eating it, you would rightfully have cause to suspect that person of perfidy.

If you’re writing Java and you’ve made your inheritance tree so deep that figuring out how anything works involves reading through 18 different classes? You’ve got too much inheritance and none of the individual classes are doing anything important. That is not spaghetti code, your code has rich kid syndrome.

Ravioli code? Lasagna code? So you’ve got a lot of easy-to-understand and self-similar components (either modules to make ravioli, or layers in lasagna), and you’re complaining? Do you have any idea how much effort went into making that ravioli? That code sounds delicious. I should summon my mother to hit you with a wooden spoon (she would never, she’s very sweet).

Oh, you’re using functional components that nobody has ever heard of, but which offer unique and clever solutions to a class of problems you never even knew you had? That’s bucatini code.

Copy-and-pasting the same line of code into everything because it works everywhere? Looks like you’ve got some orzo code.

Did you over-engineer your code and end up with something kinda stupid, but you love it anyways? Whoops you wrote some farfalle.

Fussing too much with the spacing to try to make your code into art? You have committed an act of macaroni code.

Wrote a black-box so transparent with an interface so gnarly that everything that touches it gets hopelessly entangled in the implementation? That’s a big ol’ bowl of Cavatappi code.

This is fun but it is has, at best, limited explanatory power as a metaphor.

Look, I’m going to say it: I don’t think pasta is a very thoughtful way to build a taxonomy of code smells. Pasta is lovely. Pasta deserves better than this.

Let’s not even get started on the raw deal that potted pork got.

Did you know that Sid Meier has written a book?

It’s… uh, slow, and it very much is a lot more about Sid’s life than his design philosophies.

A fun detail of the book is it lays out how little of the Civilization series is actually Sid’s handiwork: Every Civilization game has had a different lead designer, many of whom deserve more attention and accolades for their work. “Sid Meier” is more of a brand name at this point.

One funny tale in this book is how Sid sunk years of his life and absolute mountains of time into C.P.U. Bach, a generative music program that went over like a lead balloon.

Anyways, this is a digression, but it leads to a point I want to make about why a totally different game that I love, Slay the Spire, is so good.

“Games are a series of interesting choices”, said Sid Meier.

It’s a design philosophy that, I think, really informs games like Civilization. Deeply enjoyable, fun games. And every (stock) game of Civilization starts with the same interesting choices: given the resources around me, do I settle here, or explore first to find a start point with better resources? If I settle, what’s the first thing I should build?

I like “settle immediately” and “build a scout”; modern Civ games usually arrange things such that your starting position is a good place to build a city by default, and the scout’s utility in the early game is massive: they usually pay for themselves dozens of time over in goodie huts and information.

We’re not talking about Civ though! We’re talking about Slay the Spire! FOCUS, CURTIS.

Slay the Spire starts out with this whale, Neow, cruising in and offering you an interesting decision up-front.

Interesting trade-offs. Would you like more cards in exchange for less hit-points? Would you like a random power in exchange for a weak but known power?

The game’s interesting trade-offs continue as you go. You’ll be presented with card after card, deciding which ones to add to your deck, and that decision is painful every time. Each card is situationally useful and uses up space that could be devoted to other cards.

Slay the Spire is so good. Rock Paper Shotgun’s Alec Meer called it a miracle of design. We’re hitting the point in time when the games inspired by Slay the Spire are going to start rolling in because this game was so unique and so good that everybody who played it just wanted more, but Slay-the-Spire-inspired games often fall flat, because it is just so, so hard to keep decisions balanced on the knife-edge of interest the way that this game does.

I just want to talk about one tiny detail.

You start the game with 3 energy per turn, and a hand full of 5 cards that either do 6 damage, or block 5 damage. Your opening turns will involve playing 3 cards out of 5.

You have a few cards that aren’t 6 Damage (Strike) or 5 Damage (Defend), but we’ll pretend those aren’t part of the equation, for now.

So, if you draw nothing but Defends and Strikes, you can choose to

• Do 18 damage, block 0 damage

• Do 12 damage, block 5 damage

• Do 6 damage, block 10 damage

• Do 0 damage, block 15 damage

And the detail I wanted to point out is that all of the opening monsters in the game are tuned to make even this simplified decision a little bit hard.

The Cultist, for example, one of the handful of early monsters that you will fight in Slay the Spire. They have 48-54 HP, and will do 0 damage the first turn, then 6 damage, then 9 damage, then 12 damage, then 15 damage, and so on until you knock them out of the game.

These guys are quite probably the simplest monster in all of Slay the Spire. Their low initial threat and linear damage scaling make them a credible threat in Act 1, Act 2 and Act 3 of the game: Ignore a cultist for a few turns and whoops, they’re dangerous.

Notably, they don’t do exactly 5 or 10 damage, so you have to decide: do I block more than I need to in order to take zero damage, or do I take a little bit of damage now to do as much damage as I can, to stop the cultist from getting stronger.

So now, what do you do? You can math this out somewhat: you need to hit them ~9 times to win the battle.

You can just strike-strike-strike, strike-strike-strike, strike-strike-strike. 9 times. In doing so, you take just one full hit: 6 the first time. 6 HP of damage, total. Well, if you could draw only strikes, which you can’t, because there are other things in your deck.

You can play as conservatively as possible: strike-strike-strike, strike-block-block (6 damage blocked), strike-block-block (9 damage blocked), block-block-block (12 damage blocked)… block-block-block (15 damage blocked), oh, shit, he’s doing more damage that I can block every turn and it’s only going up… uh, shit, strike-block-block (10 damage blocked, 8 damage), strike-strike-strike, and we win, having taken 8 HP of damage.

Even with perfect draw, which you don’t have, you are going to have to be okay with taking some damage to get through this battle: there is no perfect play, only tradeoffs.

This opening puzzle is already a little bit interesting. The game quickly adds other cards into the mix, complicating the puzzle further. Perhaps you would like to spend 2 of your energy on a Bash? It does 8 damage - that’s less than the 12 damage you would get out of two Strikes - but for the remainder of this turn and next turn all of your remaining strikes will do 9 damage instead of 6. Or a Zap - shell out for a Zap and it’ll do 3 damage per turn for the remainder of the fight.

Interesting, right? I think it is.

I honestly have no idea how it’s possible to design and balance a game like this, although the Slay the Spire team reveal that a lot of it has been powered by gathering a mountain of data about every single person’s playthroughs of Slay the Spire and using it to pull, prod, and tweak the values for every single card.

The life-cycle of documentation initiatives at every company I've ever worked at has gone like this:

• a new employee, confused by the codebase, goes looking for the codebase's documentation

• they find some old, unmaintained documents from a previous employee, which turn out not to be terribly helpful because most of their assumptions are badly dated, incredibly old, and only describe a tiny fraction of the system

• they make a big project out of writing a new set of docs

• they end up asking a bunch of questions in the chat which helps them understand and document the system

• after a month or two they are pulled on to a big new project, leaving a new set of documents describing only a fraction of the system

• nobody updates the new set of docs

• a new employee, confused by the codebase, goes looking for the codebase's documentation

But then why do more public and open-source projects have such comparatively excellent documentation?

Open-source projects must on-board people at a significantly higher rate than internal projects.

Internal teams are usually pretty slow growing. Comparatively, products like React or Godot are probably onboarding six-to-ten new people every hour.   

Once someone has been asked the same question multiple times in the same day, a FAQ appears, then docs.

It’s different if you’re trying to actively court developers: if you want people to use your APIs without having met you, those really need documentation, examples, a first class on-boarding experience. But… most internal teams have a much more informal onboarding experience.

Things also change pretty frequently on internal projects, and there’s always someone around who knows the answer to any given question you might have. If you do develop documentation, it’s usually for people outside of your team who consume your team’s product, not for internal development. "Everyone Online All The Time" is a really bad environment for the development of a comprehensive MANUAL D’THING. In fact, I’d go so far as to say that that manual probably isn’t necessary and it is silly to keep trying to write it. 

But What About Cross-Team Interop?

This opinion is controversial, but...

I've had a long standing policy of just delivering a test suite demonstrating the operation of new endpoints.

It's not pretty, but it's sufficient. Software developers can understand code-as-documentation, I believe, especially when the code is designed to show off and probe a specific endpoint to demonstrate exactly what it's intended to do - and this documentation is by its very nature guaranteed to be correct and stay correct. We provide and verify our contract with client using our mountains of test suites.

This is a little loosey-goosey; if behavior isn't tested it's not guaranteed - but if your opposite number probes you for answers about behavior that’s undefined in the tests, that’s also behavior that there aren’t any tests for. Write some tests to clarify and test that!

Divining the use of an endpoint entirely through constructed examples really, really isn't as nice or professional as Real Documentation, but it’s… often good enough!

Pull Request Etiquette

One of my friends responded to an older version of this tirade with “simply do not allow undocumented code to pass PR” which…

The real-life Balkan micronation being built first in the metaverse

“At that point, I realised it might be easier to start a new country than change an existing one,” he told Euronews Next.

However, the area Jedlička found along the west bank of the river had not been claimed by either Croatia, Serbia, or any other country and was therefore in a state of terra nullius, in other words, a no man’s land.

That is until Jedlička - the current president of the provisional government - and the other founders of Liberland laid claim to the territory on April 13, 2015.

“We founded Liberland on April 13, 2015, to celebrate the birthday of Thomas Jefferson. We wanted to invoke the spirit of the American Revolution. We also want to combine the best elements of the American republic, Swiss democracy, and the meritocracy of Singapore. We want to put our system on the blockchain so that the government will work in a modern and transparent way”.

By partnering with Zaha Hadid Architects to create a metaverse, Liberland is creating a space for its thousands of citizens to meet without having to travel to that tiny, and as yet, uninhabited piece of land.

There are two things I want to bring to mind in response to this mad scheme.

The first one is the book “A Libertarian Walks into a Bear”, the true story of what happened when a group of radical, meritocratic anarchists moved into a remote city, collectively voted to dissolve the government, and stopped enforcing any kind of rules.

The Town That Went Feral

The answer turns out to be “lots of deadly bear attacks”, because - (simplification
inbound) it turns out that it’s often good to collectively agree on some ground rules vis-a-vis the disposal of garbage.

But, of course, they don’t actually have to suffer under the bootheel of “do as you please” - because it’s a libertarian paradise that’s exclusively virtual and will be hosted on servers that… don’t even exist within the borders of their putative “country”.

Yeah, okay, but let’s talk about terra nullius for a second.

This exact scheme was discussed in length in the Ryan North book, “How to Take Over The World”:

Whoa ho! There’s a whole chapter on this! (Which I totally recommend reading in its entirety if you have the time, it’s fun.)

In fact, the book covers using this exact scheme: look, here is some no-man’s land that nobody is willing to claim - because the land is worthless, and claiming it would weaken either country’s claim on a much more desirable section of land:

Historically this was somewhat of an example of the countries cutting the pie into a “good slice” and a “bad slice” saying “each of us gets one” and then both of them going immediately for the good slice.

Given that this dispute leaves both countries officially denying ownership over Bir Tawil in order to bolster their claims to the Halayib Triangle, several individuals have decided hey, if this land is unclaimed, then I hereby officially claim it.

But before you get too excited and set up your own governmental page on a free hosting service, you should know that claims like these are basically fantasy, ignoring the reality that:

• There’s more to nation-building than simply posting online, especially from a continent away, that you own Bir Tawil now.

• Even if Egypt doesn’t claim ownership of Bir Tawil and keeps it off all official maps, it still administers the land, and has done so since the early 1990s.

• Just because both Egypt and Sudan claim the other nation owns Bir Tawil, it certainly doesn’t mean that either is going to accept a third party waltzing in and claiming it, setting up a new country under their noses.

• Most critically, all these claims ignore the fact that there are already people living nearby, including the Ababda and Bisharin tribes, who travel across Bir Tawil and even mine the land: while technically unclaimed, this land is neither unused nor uncontrolled.

uh, then the book goes on an extended digression about a superior in theory if-still-entirely-insane plan for making a country and dozens more crazy things, it’s a very fun book.

But it does very much point out the flaws in the plan of just up and declaring some unclaimed land your own and then setting up a cryptocurrency: You can’t actually do that.

Which, uh, the euronews article’s author alludes to with this subtle jab:

Indeed, it might be a much safer option for its would-be citizens as visitors are not then exposed to the threat of possible arrest by Croatian Police.

In my last post I talked about Stanley Parable and Pathologic - narrative games - but I didn’t mention Paradise Killer, because that article was about metanarrative fuckery and Paradise Killer doesn’t DO any of that.

It’s interesting in a lot of its own ways!

Paradise Killer took me about… 13-14 hours to finish? It was pretty good.

Someone has done a murder on vaporwave island and it is your job to find out whodunit.

To be more specific, a lot of people have done a lot of murder on this vaporwave island.

You play Lady Love Dies (which might be the least strange name on offer here), an immortal “investigation freak” who was exiled from Paradise 3 million days ago, and is only invited to return after a locked-room murder spree forces the island’s egoless arbiter of justice to bring in the only person deemed capable of solving the crime. Oh, and you get back from exile by skydiving from a mile-high plinth suspended above the actual game map while the opening credits roll.

First of All, The Aesthetic

Seriously, this game takes its Vaporwave stylins extremely seriously.

“remix culture” and “meme culture” is just nostalgia by another name, and here we are, starting to see the early nineties come up in the cycle

The low-poly look is pretty crunchy and ugly - and absolutely it feels intentional and totally works as an aesthetic choice.

This, uh, is both delightful and absolutely necessary to this game being possible to make, considering how it was built by a team of maybe 3 people.

I love this game’s look so hard.

Second-of-ly, The Worldbuilding

This world’s backstory is fascinating and dark as hell. I don’t want to spoil it - deciphering it is one of the first mysteries of the game - and when you realize (early on) exactly what’s going on here - something your character already knows and is fine with - it really does change your perception of this whole colorful late-80’s paradise.

I can’t say “this world isn’t what it seems” because there’s no way for a colorful vaporwave beach paradise to seem - obviously we don’t really have much of a frame of reference for a reality lit in cyan and magenta, filled with pyramids, soda cans, and statues. I wasn’t coming into this expecting Doctor Doom Jazz in the first place, so I didn’t have a lot of expectations as for how they were going to explain things to me.

But dang, the game really goes out of its way to develop the lore and characters of its murder-heavy vaporwave universe.

Then, The Music

I say this with all due respect to the importance of Vaporwave: as an ironic musical statement it often sounds like complete ass.

You know, I love this frigging musical genre, but I’d never spin a Macintosh Plus album, except as maybe a joke, because while it’s important and influential and cool, it’s also borderline unlistenable a lot of the time.

“Curtis, why are you so devoted to a musical genre that you only like ironically?”

This game successfully realizes the dark secret of vaporwave: vaporwave is unlistenable trash.

Instead it pulls musical inspiration from a broad pastiche of vaporwave, its more energetic contemporaries like future-funk, and precursors like city pop and acid jazz.

The result is pretty darned listenable, and of course just feeds into the already very unified vision of the game.

oh, one sound design complaint: The characters’ 4 recorded voice lines each get kind of grating by the late game. Once you’ve heard the main character go “nani the fuck?” a few dozen times it ceases to be funny.

Uh Oh, The Gameplay

The gameplay in Paradise Killer is really, painfully simple. You’re rendered in glorious first-person, you get buttons for “jump” and “examine”, and you’re off to the races, to rush around a not terribly large island meeting 8 fanciful suspects and picking up literally everything that’s not nailed down. Blood statues, clues, collectible objects and soda machines are hidden in every corner of every square inch of the small island of Paradise 24 - an island that’s maybe a 3-5 minute run from end-to-end.

To make thing-hunting on the island a little more confounding, the architecture of the island is intentionally confusing in a lot of ways, and takes advantage of a lot of verticality. As an example, I had trouble remembering the exact location of the elevator down to Dr. Doom Jazz’s yacht, so I would often find myself just flinging myself off of the cliffs in the broad vicinity of his boat and hoping for the best. It usually worked out.

First-person platforming has always and will always suck total ass. It’s good that the platforming required by the game is extremely limited.

That being said, after 10 hours of bouncing around on this small vaporwave island I’ve got the whole layout more-or-less burned into my brain and I’m not excited to hurry back. (ed: I’m posting this almost 2 years after having played the game and I could still sketch you the island’s layout on a napkin)

But that’s… the frosting, around a detective game that takes the “detective game” format established by your Phoenix Wrights and Danganrompas and completely rethinks them.

Open-Ended Detectiving With No Right Answer

Okay, I say that the game took me 13-14 hours to finish, but actually I had beaten the game after about 20 minutes.

That’s because the game, having put you in charge of the investigation, is fully willing to let you go to trial at any time you want, with whatever dossier of answers you’ve accumulated.

So, having left the court-room with a no more than the scantest basics of the crime, I immediately saved the game, turned around, and kicked off the trial of the century without any leads, clues, suspects, or information whatsoever.

In the trial, I pretty much just read off of the police report, pinning the whole thing on the obvious patsy who the police had told me outright was the killer.

Result?

The judge accepted my investigation, executed the criminal, and we were all off on our merry way to Paradise 25. Roll credits. Thanks for Playing. The game didn’t even flinch, it was like “okay, I guess the guy who we thought did it did it, thanks for your help, have a nice day”.

I really like unearned credit sequences in games.

This game gives you a lot of very open-ended clues, challenges you to figure out what happened, asks you to present your findings, and never, ever explains if you got them right.

Paradise Killer lets you luxuriate in a lot of information, piecing things together as you go, and I really liked that.

That’s good and bad. There’s a level of freedom here that games like Phoenix Wright never really had - you feel more like a detective, detectiving than in games where you can’t go to trial until you have all of the exact set of facts you need to complete the trial to your best ability. That being said - the last hours where you’re 90% of the way through the case and you’re just trying to tie up loose ends can be a real slog, and some of those loose ends never really tie up as neatly as you want them to, and you just have to be okay with that.

Some More Handholding Wouldn’t Hurt Sometimes

I don’t think it would hurt the game at all to have a someone explain to you that you need to buy 10 sodas to get your hands on a vital component, or that you should try to hit all of the baths as early as possible to get three cheap, vital upgrades to your general mobility, or that half of the entire game’s content is locked behind a single silly side-quest involving finding a ghost’s fish-tank.

I think it does hurt the game quite a bit that there’s a single hard-to-find late-game location that takes one of the game’s deepest mysteries and explains the whole thing in exacting detail. It’s, like, an extremely tightly paced and difficult murder mystery unless you crack into Uncle Jeff’s Secret Crimes Bunker, containing a document “Here’s How I Did Those Bad Crimes, Signed, Uncle Jeff” and you’re like “huh”.

Although to this game’s credit, I believe you can piece most of the important details together without Uncle Jeff’s Secret Crimes Bunker, you’ll just never be as sure as if you’ve found it.

Moral Puzzle

Every character in this story is a certifiable monster, even the ones you like and the innocent ones, and that raises some real moral/ethical questions about what your goals are at trial - Cold hard truth? Justice? Sparing your friends? Sparing everyone?

Punishing everyone no matter how tenuous their involvement? Given, of course, how tight-lipped the game is about its ending, it also doesn’t bother to weigh in on this at all, even after you’ve made your choice.

In fact, that is one thing I’d like a little more of: a nice dash of denouement after you’ve done everything to leave you a little less hanging at the end of this puzzle.

Anyways

Paradise Killer. It’s probably a lot different from any game you’ve ever played.

I played the HL2 mod a long time ago:

The HL2 mod was very good. It was maybe 30 minutes long, a branching path game with a sassy narrator, where no matter what branch you went down, you’d lose. The branches are fairly well written and interesting, charmingly narrated, and mostly about the illusion of choice in (non-simulation) games: no matter what you do with the game, either the developer had to prearrange the result or you’ve broken the game and the result is unplayable nonsense.

Okay! Fine! A good little story.

What does the standalone $15 game add?

There’s maybe another hour of content added, so, it triples the length of the original game, adds more branches and more easter eggs, polishes the whole deal, and that’s what’s new in The Stanley Parable.

I was kind of over it? I feel like when the original Stanley Parable came out metanarrative was a lot more fresh and new feeling, and now it’s just starting to feel navel gazey. Marvel is engaging in metanerrative fuckery, it’s just not cool anymore.

But, uh, if you haven’t played The Stanley Parable, the standalone game is a pretty definitive way to engage with it, and it can be finished in its entirety in about 2 hours. Or (because the game is pretty devoid of any actual game mechanics) you could save yourself the money and just watch someone do a playthrough on your behalf.

Okay, let’s talk about Pathologic for a second. Pathologic has become one of my favorite games in the category of games that I refuse to play because they suck, but will happily read about endlessly because they’re fascinating.

(In case you’re wondering, that category, for me, right now, is largely occupied by Pathologic, Android: Netrunner, Dwarf Fortress, and Eve Online).

14 years ago, an enterprising young writer named Quentin Smith wrote Butchering Pathologic, one of my favorite-ever pieces of writing on Video Games.

man, that guy was a good writer, I wonder if he went on to do anything else cool

… nope? Nothing? Okay.

He wasn’t even the only person to put together an enormous thinkpiece on Pathologic. If you’ve got hours and hours and hours to devote to the topic, here’s hbomberguy.

Pathologic is Genius, And Here's Why

is that not enough 2-hour-long-thinkpiece-about-grim-Russian-video-games for you?

oh, don’t worry, there’s more

Pathologic Analysis; Themes of a Dying Classic // Анализ Мор.Утопии; Темы Умирающей Классики

Anyways: I love video essays, so I was all aboard to watch people talk about this thing for hours. Looks miserable to play though.

What does this have to do with The Stanley Parable?

Well, one of the major themes of both is that thing from earlier: examining the illusion of choice in video games. This only reveals itself if you’re willing to play through Pathologic’s miserable 40-hour-long campaign three entire times, which basically nobody was willing to do (not even Quinns!).

Pathologic’s happy to change the rules again and again about what the game’s story actually is. Is it a grim tale of a steppe town being wiped off of the map by disease and hubris? Is it the body and meat and blood of a bull representing the Earth that we live on, infected by deep wounds and dying thanks to over-extraction of resources and utopian human ideals? Is it a theatre production, being told again and again with myriad variations as you replay it? Is it nothing more than a game being played by two children? Is it all of those things at the same time?

At the very final moments of the final and most difficult ending to the game, the developers drop all pretense itself and directly address you, the player, explaining that the game is just a game, thanks for playing. All of the layers of framing intended to take you one step away from the story - the “theatre”, the “it was just kids” ending - they’re there to distract you from the fact that the game itself is just another layer of framing of the story, and at the very core of it all is a simple conversation between you and the developers where they’re writing a story to try to entertain you and you’re willfully engaging with it because you want to be entertained.

Anyways, sometimes stories will admit that they’re just stories as a “whoa” moment, explore what it means to be a story, get really down the hole of metanarrative (oh, hey there Homestuck), which is very cool the first few times you encounter it… but also seems to get less powerful the more times it happens, the more you turn the various ideas around in your head.

edit:
oh, oh, there’s a joke in Stanley Parable that might as well be ABOUT Pathologic, I forgot to mention that.

(STANLEY PARABLE SPOILERS IF YOU CLICK):

The Art Ending

The spoiler-free tl;dr is “if you play a deeply unpleasant mini-game for a very long time, you get a special ‘art game’ ending”, and the reason I’m willing to spoil that with a wiki is that obviously nobody should actually do that.

I’m not sure if I have anything useful to say about that. It feels more like lamp-shading than the Stanley Parable authors actually making a concrete point, to me, but it is pretty funny.

The American Fotoplayer is a type of photoplayer developed by the American Photo Player Co. between the years of 1912 and 1925. The Fotoplayer is a type of player piano specifically developed to provide music and sound effects for silent movies. Before movies had sound, it was discovered that playing background music during a film could aid in developing a particular mood for a certain scene. Initially, small theatres would use player pianos to produce music automatically from piano rolls.

I have a real soft spot for weird musical instrument tech.

And boy howdy, this is a weird one.

this is the most powerful man on earth

“What instrument do you play?”
Joe: yes

This is simultaneously the birth of modular synthesis and also the logical endpoint.

a child literally dies
oompa loompas:

So, The American Fotoplayer: this thing is essentially a 1920’s version of the Creative SoundBlaster.

I was just happy to have learned about this man and his wild instrument.

I’m reminded of this because of, well, riffing in the collapsing lands:

hehehehe, American Fotoplayer.

Anyways, that also reminded me of one of the funniest sketches I’ve ever seen.

I am but a simple man, and the first time I saw this sketch - a standout from the already memorably excellent “I Think You Should Leave” - I almost hurt myself I laughed so hard.

Partially because… when they said “replacement organist” and flashed to Fred Willard in front of an honest to god American Fotoplayer, I knew what was coming.

“I now see that he’s brought his own… much larger… organ.”

Beyond that, I love Fred Willard. This was his last, ever, sketch.

This man could sell earnest cluelessness better than any other actor on the planet. The great thing about a Fred Willard sketch is that he’s the butt of the joke, but also he doesn’t notice or care or seem to experience shame or awkwardness.

He feels out of place in the “I Think You Should Leave” Universe because so many of the other sketches are about a character stewing in an awkward situation that they’ve created for themselves - over-committing, doubling down, and making the whole situation worse for everyone.

But the joke is, it never works. They’re always fighting an uphill battle and losing.

And yet, when Fred Willard does it, he does it while presenting a character utterly without malice, everyone so dumbfounded by his bombast that he escapes all consequences scot-free.

I think he might be the only character in the entire series powerful enough to over-commit, double down, and get away with it.

this is the most powerful man on earth

Funny story.

So, when I lived in New Westminster (a decade ago), I walked to the quay to have some barbeque at Re-Up for dinner. While I was there, they had bacon for sale. I bought a package. I brought it home and fried it up for breakfast.

It was the best bacon I had ever eaten in my entire life.

I went back to Re-Up. “Where did you get this mysterious bacon?”, I asked.

So they let me know: a community farm that was operating out of South Burnaby.

I followed up with the community farm. The farm didn’t always have bacon, and when it did, it sold out really quickly and usually went to its CSA partners first. That was something they offered: a CSA Box: I’d pay them up-front and in exchange I would receive a box of random farm products every week for several weeks.

Community-supported agriculture (CSA model) or cropsharing is a system that connects producers and consumers within the food system closer by allowing the consumer to subscribe to the harvest of a certain farm or group of farms. It is an alternative socioeconomic model of agriculture and food distribution that allows the producer and consumer to share the risks of farming.[1] The model is a subcategory of civic agriculture that has an overarching goal of strengthening a sense of community through local markets.[2]

Y’know… like a food Patreon.

The idea of the CSA model is laudable: you’re paying their costs up front (farming has a lot of up-front costs), and then, whether it’s a good growing year or a bad one for the farm, they get the security of knowing they’ve covered their costs, and not to have to shill their product quite so hard; and you get a lot of very, very fresh vegetables. Presumably this can also cut into their profits in a really good growing year (you’re taking on the risk, but also eating in to the reward) - but they can recoup this by secretly short-vegetabling you (how would I know?), and they probably shouldn’t need to (since they should be encoding a comfortable profit margin into the system either way).

I tried it for a year and it was a mixed bag. Like, literally, that’s what the product was: a mixed bag. THIS HAS BEEN A CSA PUN. But also that is a good metaphor for the quality and quantity of the stuff I received. Sometimes: amazing. Sometimes: extremely unimpressive. Even with my modicum of cooking skill, I don’t always have a plan for a bag full of ramps.

I made do, probably learned some things.

Tiff still brings up the Very Tiny Chicken (“it was like five bites of meat each”) and the Rabbit Stew as examples of bad value for our money, though. They were still experimenting with some of their livestock and farming methods, and some of them turned out to be embarassingly low yield. Which they also freely admitted - and it was also interesting being on their mailing list and watching them learn this stuff in real time.

I did get a lot of eggs and bacon out of the deal, though, and you know what, if there was a CSA that just dealt in eggs, fresh bread and bacon I’d be set.

Ultimately: It was kind of a pain in the ass to have to drive all the way to South Burnaby for groceries once a week. I walk for groceries, which comes with a whole patchwork of entirely different environmental and social ups and downs. Eventually, I moved far enough away that it became inconvenient to keep up with (and cancelled my subscription).

One criticism leveled at the CSA model in that Wikipedia article I posted:

Many CSA farmers can capitalize on a closer relationship between customers and their food, since some customers will pay more (an economic rent if this puts the price above the cost of production) if they know where it is coming from, who is involved, and have special access to it.[1] However, some farmers participating in community-supported agriculture do not experience the economic benefits that they are perceived to obtain by participating in an alternative community-based arrangement. Galt’s 2013 study of CSA farmers found that many farmers charged lower fees and prices for their goods than would provide them with financial security.[1] This study suggested that farmers may charge less than they need to earn fair wages due to undervaluing their expenses and to offset the high costs of CSA products and make it more affordable for customers;

or, tl;dr: sometimes farmers don’t charge enough for their shit, and while a community connection helps them charge more it doesn’t always work. Spoilers.

The CSA itself, complaining that, even with their CSA, they couldn’t afford to keep operating a farm on some of the most expensive land in all of Canada, moved to Merritt, where they formed Blue Sky Ranch, stopped farming anything but pigs (which was, as far as I understand, the most profitable and successful part of their operation), and now quietly sell some of the best pork products I’ve ever had access to.

Since then I’ve bought at least a pig and a half from them. Their pork is extremely good. You do have to get on the mailing list, though, if you want to know when it’s going to be available - and you have to be willing to commit to a Lot of Pig.

And while I have a lot of ethical compunctions about eating meat, I do know that their pigs are cared for, get to roam around outside and forage, and don’t spend any part of their lives getting fattened on a feed lot or caged, which helps somewhat.

Anyways, with my CSA gone, that’s where my CSA story ended.

Until, you know, Twitter imploded, and I returned to Mastodon for the first time in months.

I started following the slow-moving-but-extant #vancouver tag - putting me into the loop about a bunch of stuff that “the sort of people who use Mastodon” would want to tell me about Vancouver.

One of those things? “Here’s some CSAs in Vancouver who are selling shares for their 2023 season”, Farmers on 57th and Skipper Otto.

Interesting! Relevant to my interests! Something that I bet twitter would never have surfaced for me.

First:

Farmers on 57th

Farmers on 57th

Okay, not gonna lie, this one looks like it’s got all of the same problems as the last CSA I was in. Their blog indicates that they are struggling, somewhat.

That’s no reason not to support them, though. My reason not to support them is much more petty: Driving to South Vancouver between 3 and 6 PM on Tuesdays? That is rush hour my dudes. Despite living in [REDACTED], a quick Google Maps test of traffic around that time of day indicates that, depending on traffic, I would have to commit 60-120 minutes per week of solo driving to this project.

I might hunt for a CSA at some point, and if I do? I’m gonna hunt for one that either delivers or has a pick-up point in walking or very short driving distance.

That’s not me worried about the environment, that’s just me going “frig, I don’t want to spend 90 minutes in my car in a week when I don’t have to”.

I am a 20 minute walk or short electric scoot from a nice permanent vegetable market where I can get vegetables that are still pretty darned fresh, and also exercise.

Okay, so, a pass on this one.

Skipper Otto

But Skipper Otto. That’s kind of interesting.

They offer the same sort of deal as a CSA, but instead of farming, you’re doing it for fishing.

Here’s the thing: getting good seafood is kinda hard.

Despite living coastally, I struggle to get my hands on good fish.

Mega-grocery chain Save On Foods? Their fish counter is … well, it’s okay. You can almost always get a bag of shrimp of unclear provenance or a plank of Pretty Okay Salmon.

You want the good stuff? Good fish markets are a lot harder to find than good butchers.

Again with the help of Google Maps, from my current location there are several independent and specialty butchers in walking distance and double-digit butchers within a short drive - but no fish markets in walking distance, and only a handful if I’m willing to commit to a slightly longer drive.

Fresh Ideas Start Here is a pretty good, if pricey, local fish market, if I make the time to hop in my car and putter over there - but largely, I don’t.

It also took me an embarassing amount of time to realize that their name spells “F.I.S.H.”. That’s some real Gen Z Devon Cole shit right there.

Anyways: good fish markets: few and far between.

And it’s also kind of an open secret that most of BC’s best seafood gets flash frozen and sold throughout the entire Pacific Rim, where a lot of buyers are willing to pay a premium for it.

Despite BC being a place where fishing happens, we’re not a great place to Sell Fish For Exorbitant Prices, so… well, we’re a fishing town where you don’t actually get to eat a lot of that fish. (This is our karmic retribution for eating all the avocadoes)

My best idea for finding really good seafood would probably be to head to the Fisherman’s Wharf in Steveston, but that’s a heck of a journey.

So: Back to Skipper Otto: You pay up-front, local fisherman go out and catch fish, you select what you want online, they drop it off at a drop-off point (my closest one is Steel & Oak in New West which is very close), and you get the fishyfish. They get a fair price and don’t have to work through one of the large commercial fisheries. You get good seafood.

They even appear to have a pretty good website.

That sounds good, I’m sold. I’m going to give it a try next year.

will report back later with my fishy findings

FISH HO

For decades one of my favorite meals has been the Tex Mex Night.

You know: Old El Paso Tacos.

This shit is up there with Kraft Dinner in my pantheon of charming mass-market meals that I ate a lot of as a kid and still like as an adult.

Is it Mexican food? hell no. Do I care? Not even a bit. (I also love Mexican food but this is not it)

There’s just something so fundamentally good about the combination of ground beef, bright orange shredded cheddar cheese, crisp iceberg lettuce, diced tomato, lime, and sour cream.

I’ll make all kinds of modifications to the basic recipe - I’ve got a (cherry tomato, jalapeno, lime, white onion, salt, cilantro) hand-chopped salsa fresca that’s always great on this, we’ve got arrays of hot sauces, I can make taco powder from scratch, sometimes I’ve done it up with slow-roasted beef or homemade carnitas or from-scratch refried beans - it goes on hard shells or soft wraps.

Just as often, though, I’ve put it together on a weeknight from packet and it’s been delicious.

Taco Tuesday is real, folks.

But.

Tragedy strikes.

After every Taco Tuesday comes a grim, unyielding, Tacoless Wednesday.

The sad reality of Taco Tuesday is that all of the ingredients get used at uneven rates. In the fridge goes some loose meat glop, maybe some shredded cheddar, some salsa - sometimes leftover tortillas, sometimes not. It’s often very difficult and irritating to re-assemble Wednesday’s leftovers into viable, balanced tacos - and unappetizing, after having eaten too many tacos the night before.

But, lo: a trick I learned by watching the internet.

You can just dump taco ingredients atop a rice bowl and, like magic, a meal is formed!

Namely, Joshua Weissman’s fluffy concoction of rice, lime, sour cream, and cilantro looked like the perfect base for a daytime leftover taco rice bowl, and… yeah. It was. it also looked 90% easier to prepare than everything else he makes

I tried it and it really worked.

The taco leftovers cleaned up in one delicious fell swoop, I felt accomplished. Full of beans.

I AM BECOME MORE POWERFUL THAN EVER

One of the white whales that I periodically chase as a software developer is that I want to share my horrible knowledge with others.

Unfortunately, as a result, I have composed a document that is definitely and unquestionably too long to deliver in a single email/blog post.

It’s still fairly rough, but I’m happy with where it is, now:

https://github.com/cube-drone/build-a-the-web-presentation

Anyways, what follows is one of the chapters (to read the whole thing you’ll need to follow the link):

Language

One of the the first questions that you'll probably come to when building a web application - any application, really - is "what language should I use"?

If you're learning everything from the ground up? The answer is probably Python or Javascript.

Concurrency Model

The reason that your choice of language matters so much is because different languages have very different models when it comes to managing concurrency.

When it comes to web applications, concurrency is non-optional. Imagine if, for example, a web server could only deal with one person at a time. It would be slow.

Handling concurrency is also really complicated - enough so that the concurrency model you choose effects every decision you make afterwards. It's a big deal.

Remember, You're Not Writing A Database

There's a common misconception when it comes to programming languages - the best one is the one that's fastest, right?

Well, not necessarily.

It's possible to write web applications in pretty much whatever language you like. The speed of your web application server isn't going to be your first scaling hurdle - and even PHP will cheerfully run a website for your first 10,000 users, no problem.

Static languages, dynamic languages, they're both fine. Some people like type systems, some people don't, I've definitely seen some pretty compelling evidence that they don't affect your productivity too much either way.

I'm pretty sure that most languages have fairly sane package management at this point - a good package manager where you can save a list of dependencies and automatically install it after pulling the repository - and most popular languages have libraries for just about everything you'll need.

In fact, what you should probably be doing, is writing applications in whatever language you're most comfortable writing code in - fast code is utterly worthless if you don't have any users, and the best way to get some users is with something - anything - that works.

The actual wrong decision here is choosing a language that's more complicated than you need for the task at hand, and wasting a bunch of time struggling with it.

Process Concurrency

"But languages like python, ruby, or PHP don't support concurrency"

Now, for those of you in the know, you know I'm sort-of lying about that - each of those languages has support for async and threads if you go spelunking in them - but let's pretend for just a moment you build a standard flask or django application in Python - that application can really, truly, only process one request at a time. It gets a request, and it has to respond to that request before it can move on to the next one. I've already said that this would be slow - but Python and PHP have been used to power some of the biggest websites on the internet. How do they do that?

Well, your operating system has concurrency built in. When you're launching a Python program in production, you're actually launching dozens of processes, each containing an identical Python program with its own fully independent memory. Then, an external program - an http server - load balances requests to all of these internal processes. In many cases this external program will also manage the whole process lifecycle for these internal processes. This external program is almost always written by people who are very smart about writing high performance code, so you're leaning on them to do a lot of the heavy lifting for you. All of the actual concurrency is provided by your operating system's scheduler - which, thanks to the fact that the processes don't share anything, means that you barely have to think about concurrency at all.

This process-based concurrency model is the simplest, the easiest to deal with. From the point of view of the program you're writing, there is no concurrency. You just have to respond to one request at a time.

If you are just learning, I strongly, strongly recommend a language that scales with a process-based concurrency model, like Python or Ruby. They are not the absolute fastest, but, remember: You're Not Writing a Database.

Async (Co-Operative Multitasking)

However, process-based concurrency is heavy. Each process demands its own space in memory. Ideally, you're writing your server programs to use very little memory on their own, but it is still a concern.

On top of that, a lot of time in web programming is spent waiting on network resources. One of your processes might send a query to a database, and then just wait ... for hundreds of milliseconds. In computer time, that's an eternity. Your operating system's scheduler will check in on that process every now and then, but most of the time it's just going to be waiting for the database to get back to it.

What would be ideal, is, instead of jumping around from waiting process to waiting process, if we could find a way to get a single process to just be busy all the time. That means any time it has to wait on anything, it just remembers that it's waiting for that thing, and goes to do something else for a while.

This is asynchronous programming - a style of programming where you have to intentionally indicate within the code "oop, this bit might take a while, don't come back to this until the thing is done".

Programming like this is hard. You have to relearn a lot of your habits to switch from thinking synchronously to thinking asynchronously - writing your software around the idea that it has to consciously give up control any time it's waiting on something to execute.

This also isn't really concurrency - it all still happens on a single thread of execution - but - this technique allows you to write a single process that stays white hot. Each individual process is able to deal with hundreds of simultaneous requests, because whenever it's waiting on something for request A, it can be working on something for request B, or C, or D, or E. If you have more than one CPU - if you want TRUE concurrency - you still have to scale out using the process model - one process per CPU - but only one process per CPU, because the process itself is handling the mechanics of keeping itself busy.

This is the scheme underlying node.js, or some of python's newer frameworks.

No Shared Memory

The process-based concurrency model is very powerful and flexible - but - if you think about it - it really limits the amount of memory available to each of your processes. Lets say you have a computer with four CPUS, and 16GB of RAM - if you're process scaling with Ruby, and you create 16 processes to jump between, each process only has access to 1 gigabyte of working memory. If you're process scaling with node, and so you only need to create four processes - one per CPU - each process only has 4GB of memory to work with.

Now, one of the reasons this is important is because a lot of process-scaled languages are also garbage collected and very flexible. Which means - memory leaks can accumulate pretty easily in the code. Which means your program can eat all of its working memory, and then die.

Also, and this is key: where do these programs keep everything? They can't keep stuff in working memory - if they do, only one of the many processes actually running on your computer would ever be able to see it. You send a request to log in on this process and then you send another request but you're not logged in on this process, nightmare.

So, for this reason - amongst others - these servers are written according to something called a "Shared Nothing Architecture" - nothing that they need lives exclusively in their own working memory - all they do is connect to external databases that actually store all of the real, important information. If you reboot one of these processes, it ... doesn't matter. Because they aren't storing anything important. This also is super important for the resilience of your systems - it doesn't matter if you reboot any of these servers, they'll just wake up and start handling requests again, as if nothing happened.

Threads and Shared Memory

Remember when I said "we're not writing a database?" That's just - good life advice. Don't write a database. It's really hard.

If we were writing a database, we'd want both full concurrency and access to all of the shared memory the system has to offer. That's when we start to get into the realm of truly concurrent programming models - which means - threads.

And where you have threads, you have synchronization issues. It's a fact of life - any time two CPUs have access to the same part of memory at the same time, you're only moments away from a whole raft of horrifying issues having to do with mutexes and semaphores and race conditions.

Go, Java, Scala, C#, Elixir, Erlang, Rust, C++, and C are all languages that let you go to town with threads and shared memory. Many of them ALSO have access to async coding primitives. You can mix and match.

One way to control that complexity of managing access to mutable shared memory is with immutable data structures and message passing. Immutable data is an enormously powerful technique for concurrent systems, because you don't have to manage access to it - it's always safe to read - the only thing that needs to be consistent is its lifecycle - that data has to be readable as long as there are still threads that might want to read it. A very common pattern for creating stable, manageable concurrent systems is by creating a bunch of little micro-systems that send immutable messages to one another - each thread almost feeling like a little processes within the application itself - this is based on a technique from Erlang, although commonly it is called the Actor model - and you'll find versions of it in many of these languages.

Another way to control the complexity of shared mutable state is with clever data structures. Using tools like atomic operations and copy-on-write, it's possible to build data structures that are highly resistant to being used in ways that will corrupt data.

Another way to control that complexity is just to... embrace the madness. Get deep into mutex town and hope to hell you don't make a mistake. This is a common tactic for C++ programmers, who are crazy, and Rust programmers, who have invented a compiler so complicated that if you can write programs for it, at all, they're probably safe to run.

Needless to say, unless you ARE writing a database, I don't necessarily recommend managing your own threaded concurrency and shared memory. In fact - if you're listening to me, an idiot, and learning things, you're probably not at the point in your career where you are ready to write database code yet.

The only place I’ve ever been able to find them is Amazon, and the only ones I have are Sodium Citrate and Citric Acid. But those powders, they do good work, and I have them both because I watch too much Food YouTube.

Sodium Citrate

The Sodium Citrate was because of this:

And it totally works! It’s great. I wonder if it’s a good emulsifier in other contexts? Maybe I should be adding a pinch of it to vinaigrettes? I don’t know.

There’s only one other thing I know sodium citrate is good for, and I hope it doesn’t help me in the kitchen any time soon:

If you’ve found another use for sodium citrate outside of cheese sauces and fattening up local vampires, tweet them at me pls. Enquiring minds need to know.

Citric Acid

The Citric Acid came out of a desire to make exactly one recipe, the Morgenthaler Lime Cordial, borne out of… well, the bartending YouTube channel I follow.

But, recently, I’ve found Another Use for Powdered Citric Acid, outside of that Exactly One Lime Cordial Recipe.

Iced Tea

I’ve been polishing my Canadian-Style Iced Tea Recipe for a long time.

When I say “Canadian-Style Iced Tea”, I mean - uh, a substance that tastes a lot like this stuff:

Canadians do not understand southern style “iced tea”.

What, it’s just tea but cold?

No, Iced Tea is supposed to be sweet and tart and a little bitter, essentially an Arnold Palmer. (In fact, the iced tea drinks we’re familiar with up here are, in fact, Arnold Palmers, there’s a direct and unbroken line between a golfer pouring lemonade into his unsweetened tea in the 60’s and the Arizona/Brisk/Nestea of today).

But… well, commercial Iced Tea is too sweet, and not bitter or tart enough. That’s why I make my own! Out of real tea, and real lemons, and by and large it comes out … sometimes bad, sometimes good, sometimes amazing.

Because what I’m making is actually an Arnold Palmer, my process is to, essentially, make lemonade with cold tea, using a process that now involves this charming “State Fair Lemonade” recipe from Food Wishes:

One of the things that finally got me on to the track of making it come out pretty well, most of the time, though, was the tasting spoon.

A lot of my earlier cooking experiments involved “doing the entire cooking process and then tasting the food at the end to see how I did”. As I get older, I’m starting, gradually, to learn to actually taste the food now and again, and, having done that, attempt to balance the flavors somewhat.

And so, the current iced tea recipe is a careful balance between bitter (provided by the tea, brewed a little aggressively to bring out some bitter notes), sweet (provided by oleo saccharum and simple syrup), and tart (provided by lemon juice).

And that’s where the citric acid comes in. It’s great at that final step of balancing tartness after I’ve added lemon.

Technically, I could just keep squeezing more and more lemons, but… lemons are expensive, and I have this whole bag of acid right here >_>. That Good Host iced tea up there is definitely using citric acid to power its mock-citrusy punch (as does Kool-Aid, a packet of citric acid, food dye and artificial flavors) and, in fact, by using a bit of citric acid I’ve kinda hit closer to the flavor I’m actually craving: fake, sugary, tart, processed, canned Iced Tea… but better.

I ended up using two teaspoons in my 2L jug, and this is possibly my best iced tea yet.

So, mission accomplished: my fridge has a couple of liters of homemade ice tea in it.

I think I’m going to name this batch “Lil-Nestea-X”.

Here’s a final screenshot.