#bugs

Software bugs and problems / 73 posts

Newsletter
  • Get a newsletter digest every Friday:
Contact

Send me feedback, tips, bug reports, and anything else:

About me and the blog

My name is Marcin Wichary (he/him). I’ve worked as a UX designer, typographer, front-end person, and manager at Google, Medium, and Figma. I’ve also written a book about keyboards and typing, gave talks, and published essays about design, typography, and technology.

Unsung is my blog about software craft and quality.

More info about Unsung

Send me feedback, tips, bug reports, and anything else:

More info about Unsung

Mailbag: Halloween 2026

I’m curious what you thought about the Halloween spell on Unsung! In case you enjoyed it, here are some follow ups I collected since publishing:


A few people online suggested the distinctive and creepy “I can do it” Monopoly Deluxe sample is from a cartoon Ren & Stimpy, which premiered not long before the game. I found an example that’s very close, but not quite exactly like the one from the game. (It’s not creepy in the video!)


Nik Clayton added some color to the YouTube red and blue squares mystery, and specifically to the name of the YouTube channel – “Webdriver Torso”:

This was a test not just of the video encoding pipeline, but of the entire end-user experience. So rather than using an API to upload the videos directly, a web browser was controlled, aka driven by a script to navigate through the YouTube UI and upload the random videos.

This was done without showing any of the browser UI on the screen so it could be completely automated, often referred to as running the browser in headless mode, or if you prefer, just the torso. Hence “Webdriver Torso” as the account name. Obvious if you know the lingo, completely baffling if you don’t.


Daniel Vincent wrote to me to explain the bug that caused the texts to my date to go completely missing:

I work in the messaging business and I can tell you exactly why your use of typographer’s quotes caused mayhem in SMS. Back when the iPhone came out most carriers only supported the GSM-7 character set. Originally SMS only supported ASCII, which gave you the 140 byte limit. By using a 7-bit GSM-7 encoding they could cram 20 more characters into a message and also support certain extended characters (accents, etc. for languages that needed them).

Needless to say, typographer’s quotes fall outside these character sets. When the messages were sent, the Unicode data would either get corrupt or the carrier (inbound or outbound) would mangle the message in other ways. This situation was different in other parts of the world – e.g. Asian countries – which adopted different character sets. (There was also the Latin-1 character set, but it did not fully cover Unicode and characters like typographer’s quotes were outside of it as well!)

Other consequences of using characters outside the set may break the byte counting used for message concatenation […] resulting in only the first segment being delivered or no delivery at all.

When Unicode support came to SMS in Western countries they supported it using UCS-2, which translates Unicode into a byte format which can be carried over SMS. This was about the time when Western countries started seeing emojis and such in their text composers. UCS-2 also has the downside of cutting segment length in half (to 70 characters) because it’s a double-byte encoding. This could increase your SMS bill back when people were charging per-SMS.

It’s an interesting design challenge that might not be solvable. There was no way for my phone to ask the carrier whether the quotes were supported, or whether the message was received. You could imagine some sort of a situational warning that my special character use might cause the message to not appear, but design of warnings is a hard thing and the message would have to be vague. What if this scared me for life, fearful of using other characters, or future emoji, or texting in general?

Lastly, I could imagine the curly quotes to be replaced by straight ones quietly in this context, but… that ruins typography for everyone, and it’s entirely possible there I was one of the very few people on Earth facing this particular problem.


A conversation with Nikita Prokopov made me piece together some of the iPhone jump scare bug conditions.

The reason the touch screen might still respond to touches after clicking on the lock button is that the lock button still waits a bit to detect whether you clicked it twice for Apple Pay, or thrice for an accessibility shortcut. (If you disable both of these features, the problem disappears!)

You might ask: why is the touch screen active if the phone is only waiting for the button press? Likely because… it’s cheaper.

I don’t mean this disparagingly. Code needs to be as simple as possible. Disabling the touch screen would mean having to re-enable not just upon waking the phone the next time, but also at the second button click, too – and that could become a source of new bugs.

But Prokopov cast a shadow at “never caused any problems”:

Same, but right pocket and I was getting letters a and z inserted into text fields that I will discover later after unlock. Drove me crazy.

It seems that Apple doesn’t realize that their decision might be resulting in all sort of phantom touches for people. (I filed the bug inside Apple’s systems as FB25320712.)


Vis-à-vis Pac-Man’s sound bug, someone unearthed a bug report thread where people complain about it as it’s happening. At least this group of people identified it as coming from Pac-Man relatively quickly, but it’s still hard for me to read all these, even 16 years after:

Disabling CoolPreviews did the trick. You guys are right... definitely a screw up somewhere along the line. I was getting sick to my stomach hearing that sound. Thank you for the information.


Lastly, I got an email from Russ Segal, the creator of N.Y.C. The Big Apple videogame – and its bug that scared me so much as a kid:

I had no idea that bug was there.

I can tell you exactly what is happening. The old Atari computer did not have enough memory to keep the picture of the whole city at once, so the program just had a basic map of the whole city, not a whole picture. As you drive horizontally, the program only creates a vertical “slice” of the picture of the city – centered on where you are. And just before you drive off the end of the picture, it paints the next slice in front of you.

When you went backward on the bridge you fell off the left side of the available picture, and the program painted more city for you. But because you are technically “off the map”, the city map is being read incorrectly – with some sort of misalignment. Not only will this make the buildings and blocks look weird, the painted city streets do not line up with where the cars think they should drive. So the cars will crash into stuff that is not supposed to be there.

It was fun to see that message in my mailbox, and fun to see echoes of computing history: the way NYC The Big Apple did it is not exactly the same as streaming in Grand Theft Auto, but it’s a similar category of creating reality on demand just ahead of where the user is looking – and you can now imagine all sorts of similar GTA bugs that happened internally at Rockstar as the game was being made.

“Everybody loves a good underdog story.”

A fun video from Vidya James about a specific moment in The Legend of Zelda: Majora’s Mask on Nintendo 64 that starts with a bug (similar to this thing we talked about once), and ends with a fun effort to find the perfect conditions to put that bug to some good use:

This is in some way adjacent to the Mega Man glitch story, and also the Quake speedrun story, but there’s a few different angles here: statistics, brute forcing, and code analysis.

But I also feel like this in a strange way talks not just about perseverance, but also the value of… prototyping, maybe? Some people can see in their mind’s eye a faraway goal and aim for it. For others, seeing a smaller step succeed opens up their horizons: “If this worked… what if we aimed for something even further next?” This video has a few of these moments, but I don’t want to spoil it.

Pac-Man’s siren call

It’s the last day of Halloween Week on Unsung, where we’re sharing scary, spooky, and creepy stories. This is a story of how my bug scared others.

In 2010, Google’s homepage celebrated various occasions with reimaginings of its own logo called doodles, but we wanted to do something extra special for Pac-Man’s upcoming 30th anniversary – and through a set of circumstances that began with me randomly sitting in the cubicle right next to the doodle team, I was asked to write the code.

It was, frankly, a terrifying proposition. The homepage was then a very important destination, and my job title was only adjacent to “software engineer.” But I started researching the game and recreating it all in HTML and CSS, not dissimilarly to the iPod Apple just put on their pages to celebrate a different anniversary.

(The research was tricky because we didn’t want to reach out to Namco for help too soon, instead planning to wow them with a close-to-finished doodle. Luckily, some nerds on the internet researched Pac-Man intensely, so I could stand on their pixellated shoulders.)

It was important for me to stay truthful to the original game, with only some very deliberate exceptions – the price of entry was the playfield having to resemble Google’s logo, and I also added a Ms. Pac-Man mode as an easter egg; the already-classic I’m Feeling Lucky button was reimagined as Insert Coin. I even added a few bugs that I learned existed in the original Pac-Man. But I also introduced at least one important bug of my own making, one that backfired on launch day.

We wanted the game to have sound, because so many of Pac-Man’s sounds are beyond iconic: the starting melody, the waka-wakas, the death jingle. This presented a little technical challenge, since I hoped for the doodle to be a showcase of what pure HTML and CSS could do, but sound still needed quiet (huh) support from Flash. However, Flash was, by then, installed in a lot of browsers, so that worked out okay.

The project was all was going really well. I had fun coding the game and we seemed to have fun playing it. Namco eventually got onboard, too, including greenlighting the Ms. Pac-Man addition that I only later learned had a pretty complex political story.

We felt so happy about the progress, as a matter of fact, that the leadership wanted the doodle to feel even bigger. And at some point, we thought about the game autoplaying on the homepage after 10 seconds of inactivity – just to let you know that you could have some fun in a place you might not have expected it.

I was happy with that – if there was anything scary about it at the time, it was only the thought of my code getting even more exposure – but I wasn’t worried about distraction, since the homepage was not a destination page you would ever linger on.

As you can piece together, Pac-Man would also, as a consequence of all these decisions, autoplay with sound. We knew that, I think, and in that moment it felt like… it would probably be okay. In hindsight, it wasn’t okay, but it also was not okay in a way that none of us expected.

The launch day came. A couple of people on the team and I pulled an all-nighter that included putting in some finishing touches, and preparing an internal tournament version of Pac-Man. Personally, I was petrified. I was but a designer on the user experience team. Sure, my code went through all the proper reviews – but I still couldn’t believe it would be allowed, verbatim, on one of Google’s most valuable properties.

We toggled the switch at 9am San Francisco time. Within hours, the world once again went wild for Pac-Man. Soon, I watched feedback arrive in torrents too huge for me to ever catch up with. I was asked to do press interviews. I saw Twitter crash. Most importantly, I witnessed reports from all over the world of people playing Pac-Man in all sorts of circumstances, on all sorts of devices (HTML!).

And indeed, we got a few reports of the “there is a really scary sound coming out of my computer” variety. But they didn’t come through the channels we expected. And when we suggested “the quick workaround is just to close the tab with Pac-Man,” invariably the answer would be:

“What Pac-Man?”

This is what we figured out over the next frantic few hours. Some people using the then-ultrapopular Firefox installed an extension called CoolPreviews, which allowed them to quickly preview pages by hovering over links. The extension would quietly start at the same time Firefox was opened. And it would immediately, in the background, invisibly and unbeknownst to the user, open a website. I am not sure if that decision was to prime the cache, or whether it was just a forgotten placeholder.

That website was Google’s homepage.

You probably already know what happened. On that particular Friday, google.com had an auto-playable Pac-Man doodle with the sound on. If you used Firefox with CoolPreviews installed, the plugin would quietly open Google’s homepage in the background whenever you launched the browser, and 10 seconds later…

Imagine this for a second. You sit down Friday morning and power up your computer. For you, there’s nothing unusual about this Friday. You don’t have to use, or even know about Google. You might not know what browser you use — or what a browser is. As a matter of fact, you might not even be using your browser; perhaps it has been minimized and sits unobtrusively in the toolbar at the bottom of your screen. You might not know about CoolPreviews, or even the concept of plugins or extensions. Perhaps you’re just checking your mail or warming up for today’s first round of Solitaire.

Then, out of a sudden, out of your speakers comes blasting a siren of an invisible Pac-Man game having infiltrated your computer in the most unusual manner.

On repeat.

I know Google feels different now, 16 years after this story took place. I know we are all tired of websites that autoplay sound and that decision we’ve made feels uncomfortably close to “growth hacking.” But the story takes place in that slightly more naïve era of 2010.

I pushed a patch within hours. It ended up being the same solution many browsers do by default today – we added a visible mute button, and you now had to first touch the game in some way (a keystroke, a click, multitouch, or the Insert Coin button) for the sound to activate. Since CoolPreviews didn’t do that, it fixed the “possessed computer” problem. Ironically, I don’t believe we ever heard of normal people being bothered by the autoplay – it seemed that indeed, few people stayed on the homepage for 10 seconds doing absolutely nothing.

The funny thing is that emergency live-patching internet’s at the time most valuable homepage was perhaps the scariest part of that day for me, but that completely went over my sleep-deprived head.

And eventually, my job title changed. How close it felt to a “software engineer” is up to you to decide:

I wrote a story with the same title in 2015, but it got mangled online, and I’m unhappy with the writing now – so this is basically a complete rewrite of that essay. You can still play Google Pac-Man doodle, with the sound now reimplemented sans Flash.

For love (of typography)

It’s Halloween Week on Unsung, where we’re sharing scary, spooky, and creepy stories. This is another true one.

I’m the kind of a strange person who presses ⌥[ and ⇧⌥[ and ⌥] to get to the smart quotes directly from the keyboard. Yeah, I’m doing it right now. Yeah, it’s awkward. Yeah, I know that these days a lot of software automatically introduces curly quotes for you – I even wrote some of that software myself at Medium – but I started doing this in the early 2000s, and you know how motor memory goes: Once it’s all there, it feels so natural there’s no reason to change anything.

When the iPhone first came around, it was a similar story. The automatic curly quote routines weren’t there yet, but if you pressed and held the straight quote key, you’d see a little popover, and could move your finger to the proper typographical quote:

Yeah, it was awkward. Yeah, I was doing it anyway – slowly at first and then, as my fingers got used to it, more eagerly.

At around that time, I began seeing someone. We went on a date, and started texting each other, but from early on, there was something off about our conversations that I couldn’t quite put a finger on. There were chats that ended strangely, and the reactions to my texts that weren’t what I expected.

I initially chalked it up to getting to know each other, to the awkwardness of texting, and all that. But then, in real life, things were strange, too – the few dates we went on trended downward, and after two weeks or so and a short fight, it was over.

Something didn’t sit right with me, though. One of the accusations in that last fight was “you don’t respond to my texts,” which didn’t feel right to me – and, as a matter of fact, it was me who felt that way.

The accusation stung. The evening after a breakup, I looked at our message history more carefully, trying to make sense of it all. It was, I imagine, both slightly pathetic and perfectly human in a way post break-up activities are.

But that night it paid off, as I found out something that I did not expect at all. I don’t know how to build up to it, so I will just say it:

The other person has never received any of my texts where I used smart quotes or en dashes.

I’m not too eager to revisit those old messages that still exist somewhere in the depths of my phone archives, but you can imagine it looking something like this:

In hindsight, it made some sense. I was on the first iPhone, she was using an early Android device. In the famously finicky SMS flow, something ended up just quietly rejecting any of my texts with non-ASCII characters, without any warning to either party. Any time I tried to do the right typographical thing, I unknowingly sabotaged the burgeoning relationship.

Imagine me, on a sad night some time in the late 2000s, scrolling up and down iMessage, at the moment I pieced it all together. I must have stood up from the couch. It really did feel like the “I’m seeing dead people” cinematic reveal, in more ways than one.

I never reached out – our compatibility challenges felt bigger anyway – but imagine trying to explain any of this to anyone under these circumstances. In the end, there was only room for one kind of love, and it was my love for smart quotes.

“Players are still trying to find the alternate reality that might be hidden underneath.”

It’s Halloween Week on Unsung, where we’re sharing scary, spooky, and creepy stories.

Boku No Natsuyasumi (“My summer vacation”) was a 2000 PlayStation video game, exclusive to Japan, which portrayed a nine-year-old boy on his vacation in the countryside. The game was meant to be calm, relaxing, open-ended, and without specific goals, focusing more on the atmosphere set by its hand-painted visual style and calming music.

The story started on August 1, and the game had a fixed ending at the the month’s conclusion. However, its code came with a user interface bug which – under some conditions – allowed players to progress to the next day. Since the game didn’t even anticipate another month, the following days were referred to as August 32, August 33, and so on:

After loading a “clear data” save file, players can back out from a menu they’re not supposed to, which confuses the game enough to load the final day as a normal day, allowing the player to go to bed and save as usual. Logically speaking, the game shouldn’t work at that point, but instead it carries itself forward into August 32nd, which begins as if Boku is still on vacation.

That had consequences that are not hard to imagine in a game written in a 1990s programming environment: both game data and visual assets were now being interpreted from places in memory that were not prepared for this use. This resulted in particularly creepy outcomes – glitched text, empty rooms, garbled textures, characters missing limbs and torsos, and people floating in the sky:

Come to think of it, this is not that much different than the spooky NYCTBA city I mentioned a few days ago. But for some reason – perhaps because of the contrast between the calm nature of the game, and the creepiness of the discovery – this particular bug blew up.

Perhaps via the same corners of the internet we discussed yesterday, the game attained a certain notoriety, and “August 32” became one of the big Japanese gaming urban legends. Creepy video walkthroughs, often enhanced with horror-like music and visuals, became a whole category. YouTube videos from channels focused on mysteries and weird phenomena followed.

The creators’ reaction was a mixture of bewilderment, embarrassment, but also a bit of pride…

I was super surprised when I heard about it, but I was also at the same time kind of impressed. “Wow, it’s not breaking the game even though it’s a bug.”

Of course, it may not be allowed for me to think like this, but I did feel a tiny bit of pride it’s not a “good” bug, but a cool bug. I found out about it a year or two after the game was released, so my first reaction was just super surprised about it.

Millennium Kitchen as a company really cares about the quality of its games, so we do our bug checking really thoroughly. You could probably tell that the Bokunatsu series is one with very few bugs compared to other games that are out there, but maybe it was a trick from the gods to have this bug. The program house that programmed the game is really talented and is a really high-quality team, so it’s not their fault at all.

…although this all also complicated the sequel. Despite explanations and protestations, people tried to find the equivalent of August 32 in the new game, confident it must exist there, too.

Thank you to Sean Kelly for letting me know about this bug/​phenomenon.

A set of rectangles getting exponentially angrier, too

It’s Halloween Week on Unsung, where we’re sharing scary, spooky, and creepy stories.

In July, I shared a video showing how strange visuals can get as you moved them further away from [0, 0, 0], and they start to be affected by the inherent limitations of floating point numbers.

In response to that post, one of the readers (thank you, Ronan!) shared a similar video from a game Outer Wilds:

But I was curious if I could see something like this in a productivity app.

I mentioned that Figma didn’t allow to move the viewport past a certain safe margin, but I since found a loophole: If you move an object off the safe area, and then invoke the Zoom To Fit command, Figma will actually allow itself to scroll further and further into the territory where laws of physics start to loosen up.

It’s technically a bug, although I don’t believe it’s even worth fixing. However, it allowed me to do something fun. Behold, a timelapse of a set of macOS mock-ups deteriorating as you move them further and further away, to completely disappear when the X value reaches around 2 billion:

“Dear Human”

It’s Halloween Week on Unsung, where we’re sharing scary, spooky, and creepy stories. This is a story of a second creepy bug I remember from my childhood.

The Monopoly Deluxe computer game from 1992 fascinated me for one reason that you will understand even if you know me only a little bit: despite not running on Windows, it had a really elegant rendition of a Windows-like user interface.

The game came with a pull-down menu, two kinds of keyboard shortcuts, and fun sounds. There was a history log, with font sizes! There was good typography. It was, in some ways, an improvement over its inspiration, sporting gentler fonts, nicer shadows, better bezels, and cuter animations. In hindsight, it was maybe the epitome of that particular design style, more thoughtful that it needed to be and done by – I felt it even then – someone who really cared about user interface.

It was still Monopoly, of course, and there were better games around. But I remember the interface of it all, and I particularly still remember one very strange moment.

The game allowed you to play against one or more computer players. Instead of happening quietly inside the CPU, the computer’s turn was visualized exactly like a human player’s would be. People awaiting their turn would still see die on the board, pawns moving, dialog boxes for purchases or renting or chance appear, and then… the buttons pressing themselves. This was another thoughtful design decision, making it easier to feel you’re playing against someone else, rather than a mindless algo.

That decision also came with some interesting consequences. One was the fact that, under some circumstances, you could beat the computer to pressing their own buttons. Instead of blocking that action, the game responded with a playful easter egg message that looked like this:

Like many other in-game actions, the message was accompanied with a sound. But this one felt different than all the otherwise joyful audio effects in the game. It was someone’s voice saying “I can do it” – perhaps a sample from a movie or another game, perhaps a reference to something. Even today, I have no idea. Without that context (if any existed) the voice felt… honestly? Intensely creepy. It was someone’s voice, or maybe even something’s.

Just listen for yourself:

I’m telling you all this from the perspective of today, when I understand all of bits and pieces.

But the way I stumbled upon it back in the early 1990s was this: I played against computer players for hours without ever seeing the “Dear Human” dialog or the voice sample, even once. But then, at some point, the game locked itself. Maybe it was an interface race condition, or maybe some other bug. In short: It was a computer’s turn, but the computer wasn’t doing anything. Tired of waiting, I clicked to rush things forward, and then… that creepy voice startled me. Worse, all of my subsequent clicks were accompanied by the same dialog box and yet another appearance of that terrifying sound sample. The game thought it was a computer’s turn and prevented me from doing stuff, but despite the creepy proclamations, the game also wasn’t doing anything itself.

Imagine a young me, playing the generally heretofore fun game late at night, when suddenly everything grinds to a halt, and the tone shifts completely. My keystrokes and clicks go nowhere, and I’m trapped on a virtual Monopoly board with a frightening voice – somewhere between a child, a robot, and the Twin Peaks’s Red Room – saying, over and over again:

I̷̳̦͉̯̎́̈́̎͛͘͜ ̵̹̀̓̃̇̃́C̴̼̜͔̈͐̈A̴͍̤̩̤̐̃̀̑̂͌͜N̶̬̅́̔̅͘͠ ̶̦͎̣͚̦͕͂D̵͙̰̬̲͎̩̒̇̒̕Ŏ̷̺͉̔̚͠ ̷̡̙̥̝͍͈̽͂́͒͋Ḯ̵̧͓͉͉͔̰̓T̴̩̥̤͌̓̇̉̂̒

I’ve since seen many ways in which interfaces got stuck, but this was the only one I felt like the UI became absolutely possessed.

To run the game yourself, go to the Internet Archive, click on the big green button, wait until the board appears, press Ctrl+Q to exit the game (or use the right click menu), type mp digi=ibmbak.com to run it again (now with sound), wait until the board appears, press Ctrl+N to start a new game.

The Swiss Cheese model, pt. 4: The iPhone jump scare

It’s Halloween Week on Unsung, where we’re sharing scary, spooky, and creepy stories.

The first time I encountered this bug, years ago, I jumped up my seat. I was listening to the music on my iPhone and suddenly, for no particular reason, the music got extremely loud. I frantically held the volume down button, calmed down the sound, and didn’t think much about it.

But it happened again a few days later. And then again. And again.

I slowly started paying more attention to this, trying to figure out what might have been causing it. I started piecing together that it wasn’t wholly random: I noticed whenever it happened, it seemed to be only when I started or resumed the music – but not every single time I did so. Then, I also noticed it only happened whenever I was putting the phone away.

Eventually, I figured out the whole sequence of events.

In 2019, Apple changed the design of the volume indicator so that it went closer to the physical volume buttons. Here’s before and after:

I praised the contemporary version of this animation earlier on Unsung, but what I didn’t mention then was that it wasn’t just a visual change. No, the new control was also interactive. Once you popped it up on the screen, you could drag the volume up and down with your finger:

I never noticed that, nor would I ever want to change the volume this way, particularly since the only way I knew how to invoke it was with my fingers already on hardware volume buttons.

A second component? For reasons that are likely intentional, but I don’t personally understand, the iPhone doesn’t cease touch detection in the few hundred milliseconds between clicking the lock button and the screen completely fading away.

And then, the last thing: It turns out that as I was putting the phone away into my left pocket, my thumb would graze the screen, near the left edge, always in the same position.

That position happened to be the location of the interactive volume indicator.

I think you can assemble the whole puzzle now. Occasionally, I would start playing the music, instinctively adjust the volume with one of the buttons, lock the phone, and put it in my pocket. Adjusting the volume would make the control appear, and the control was ready to accept touch input, too. Locking the phone would not immediately shut down touch detection. As the phone was sliding down my pocket, the volume controls still on the screen, the screen about to fade out but still responding to touches, my thumb would graze the volume control – and while the thumb was stationary, the phone would be moving down into my pocket quickly, so it felt like an upward slide.

Every single one of those instances, it was me who accidentally turned the volume all the way up.

This all needed to happen quickly, almost as one gesture – but that is exactly how it goes if you’re doing it the same way for years. As a matter of fact, here’s a video of how it happens, and it’s so quick you cannot see anything:

(Unsung doesn’t support audio at the moment, but you can watch the same video on YouTube to hear the sudden volume increase.)

The funny thing is that I was likely doing this for years, but it never mattered, as my accidental swipe up didn’t target anything on the screen. It was only with the introduction of the interactive volume control that the Swiss Cheese model was complete:

  • the control was interactive,
  • there was no (accessibility?) option to make it not interactive – which I would want anyway, since I sometimes activate this control in other contexts, too, and never do it intentionally,
  • locking the phone still made the screen accept touch inputs for a moment,
  • as I was sliding the phone into my pocket, my thumb ended up being in the perfect position to change the volume,
  • it just happened that the movement of the phone and the direction of the control resulted in the worst possible scenario – volume going all the way up.

Here’s the tricky part: It’s been years since I figured out the sequence of events. I know exactly what happens. I know how to avoid it. Yet, those things happen so naturally, that I still occasionally blast music right into my ears and scare myself to death.

The previous three times we talked about the Swiss Cheese Model, the examples were more cerebral. This one is visceral and frightening. I hate this bug so, so much.

My first visit to New York Cities

It’s Halloween Week on Unsung, where we’re sharing scary, spooky, and creepy stories. This is my memory of the first bug that freaked me out, and perhaps the first bug I ever remember witnessing.

N.Y.C. The Big Apple walked so that Grand Theft Auto could drive.

Well, not really. But the 1984’s awkwardly-titled game for 8-bit computers could be seen as a spiritual predecessor of the first GTA. Your job was to drive and walk around New York City. If you crashed into another car, your car would be towed. If you ran out of fuel, you had to use the subway – or go on foot. If you then fell under another car, you ended up in a hospital.

These were the map mechanics. The overarching narrative was as complex as 1984 allowed: You were supposed to dip into various areas and buildings, and complete different minigames hiding within each. The post office hid a clone of Frogger, Central Park was a facsimile of Qix, and the subway offered shades of Mario:

There were twelve areas, and I believe you had to visit and finish all of them to win the game. (You can watch this walkthrough to see someone doing it all.)

The minigames themselves were hard, and driving in New York appropriately stressful, but what added to the pressure were three clocks ticking along. One was the fuel gauge in your car. The second was cash in your pocket – running out meant automatic game over. The last one? A literal clock, rendered in the upper right corner. You only had one in-game day to accomplish everything.

I am not sure how popular NYCTBA was. Its reception felt mixed. Here are two modern reviews from Atarimania, clearly written from two different coasts:

The most aggravating game unleashed on the [Atari] platforms that I can think of. Horrid controls and collision detection/​responses, pathetic graphics, annoying sounds.

This game is more than merely the sum of its parts: The many little arcade games are embedded into a very dynamic and amusing traffic simulation, which combines the numerous, fairly challenging tasks to a very satisfying whole.

Personally, I was fascinated with it, and the GTA connection above came to me not just from the vehicular carnage, or the top-down view used by GTA before it embraced the third dimension. NYCTBA also tried to be cinematic; at the beginning of the game placing you just outside New York City, so you could actually start by driving into it. In your mind’s eye, you could imagine a classic Hollywood shot revealing the city’s skyline – but realized with the limited production value the computer’s eight whole bits provided.

And that one decision happened to come with the first bug I ever remember encountering as a little kid.

Upon game launch, the only thing you were meant to do was to drive right into the city to begin your adventure. Even moving your joystick left had the car moving right toward the buildings.

But the game’s author didn’t predict you could do another thing: Wait. Specifically, wait for over 13 minutes with your car idling, watching your fuel meter go all the way to zero.

At that point, the game declares YOU ARE OUT OF GAS in a classic Atari font, followed by a familiar routine – the car disappears, and the player is ejected to continue the journey on foot.

Except now, you can walk left.

And what is going on to the left is truly frightening. The road ends and you encounter another city… a nightmare city of sorts, with cars changing shapes, driving into the buildings, and crashing into each other.

Get run over by one of these mangled cars, and things get worse – you travel forever over a surreal 8-bit nightmare world, with random disconnected streets, to a land in the middle of nowhere. It’s a creepy mirror world, an endless universe filled with broken cities where the rules of time and space don’t apply, landscapes echoing with sounds of car collisions that never seem to cease.

(I uploaded the entire experience, with sound, to YouTube.)

This freaked me out so much as a kid I remember waiting for many days until trying it for the second time.

Many years later, I have an inkling how this bug came to be – the programmer didn’t remap left movement to right for walking, because you were not supposed to be able to walk on the game’s initial road – and I could probably fire off an assisted emulator to understand the rest fully. Was it some overflow somewhere? Some memory corruption? Some version of Pac-Man’s kill screen? I could probably even learn stuff from it.

But I think I want to leave this alone, this strange memory of a rare bug in a forgotten game. In my head, it still feels like a fireside story, something that no one would believe actually happened, a mind-bending anomaly that frightened me some two decades before I myself got to visit The Big Apple.

To play the game yourself, go to Atarimania and click the Download button to get the ATR file, then go to this browser-based Atari 800 emulator, click on the hamburger menu, click on Boot Image, and point to the ATR file. Then, press F4 (start) – or press ⌘K, and search for Start. Then, use arrow keys to move around. Left Shift is your solitary fire button. If you press space to pause, just move the joystick again.

“Scaring the daylights out of unsuspecting users”

It’s Halloween Week on Unsung, where we’re sharing scary, spooky, and creepy stories.

In 2018, users of the still relatively-new Amazon Echo devices would occasionally hear their Alexa… laughing. It felt completely unprompted, and creepy as hell.

There are so many memes and exaggerations that it is hard to find the genuine recording of the synthesized laughter, but I think this video from WTNH News8 captures what it genuinely sounded like:

There’s not much to the mystery, so I’ll jump to Amazon’s explanations to the story, as excerpted in this Ars Technica article:

In rare circumstances, Alexa can mistakenly hear the phrase “Alexa, laugh.” We are changing that phrase to be “Alexa, can you laugh?” which is less likely to have false positives, and we are disabling the short utterance “Alexa, laugh.” We are also changing Alexa’s response from simply laughter to “Sure, I can laugh” followed by laughter.

Combine this with potentially overeager wake words…

It’s not uncommon for Echo devices to hear sounds and mistake them for a user’s wake word. Amazon’s smart speakers can be programmed to respond to a few words: “Alexa” is the most common, but other options like “Echo” and “Amazon” are available as well. These bouts of laughter could be a byproduct of Echo devices mistakenly hearing their wake words.

…and it all starts to make sense. “Echo, laugh” is three grunt-esque syllables and I can imagine other words or even noises interpreted as these.

But one of the commenters under the article had a good observation:

I’m confused what circumstances could possibly lead to this behavior. Why does Alexa even have a “laugh creepily” response?

Perhaps this was nothing more than a programmer trying to add something “cute” to software, and that idea backfiring horribly. It feels similar to all those random and awfully cheap Google easter eggs when you search for specific phrases that randomly change the font to Comic Sans, or rotate the screen, or do other basic things, just because that’s “fun.” (You know me, I will never miss an opportunity to hate on these.)

Anyway, it seems like the problem went away after the described patch was implemented.

The original WTNH News8 video continues with “One Twitter user even reported an Amazon Echo that began listing the names of local funeral homes and cemeteries without prompting,” and the idea of someone pranking the news team on Twitter was the thing that made me laugh.

Mailbag: October 2026

First of all, I wanted to send a thank you to everyone who ever sent me an email or a message. I read all of them, but can’t always respond timely – and sometimes at all – but I enjoy receiving those, and learn a lot from them.

I wanted to excerpt a few things I received in recent months, so that you can enjoy them, too!


Gabriel Roth pointed an obvious flaw in the Ishmael editor’s Ghost Cut implementation that completely eluded me:

You didn’t mention perhaps the worst thing about the Ghost Cut feature in Ishmael — sometimes I want to move text between apps! If I cut something in Ishmael and I want to paste it into BBEdit, I’m out of luck. The “solution” is to copy it first, but the idea of changing cut + paste to copy + cut + paste in certain cases but not others makes me shudder.


Ben Zotto sent in a 2006 essay by Joel Spolsky that covers the just-mentioned February 29, 1900 bug on a different occasion.

“So, it’s a bug in Lotus 123?”

“Yeah, but probably an intentional one. Lotus had to fit in 640K. That’s not a lot of memory. If you ignore 1900, you can figure out if a given year is a leap year just by looking to see if the rightmost two bits are zero. That’s really fast and easy. The Lotus guys probably figured it didn’t matter to be wrong for those two months way in the past.

Spoiler: Bill Gates makes an appearance.


A while back, I ended a post saying “Who would ever benefit from it behaving this way?” A reader wrote with this fun anecdote:

My work buddies coined an absurd acronym for those absurd UI misses: HCTPBWIW

How Can This Possibly Be What I Want


I received a letter from Pierre-Luc Gagné, explaining in some detail the mysterious Canadian keyboard with unique symbols I wrote about last month.

The answer to the mystery: this keyboard was used by Canadian government, which for a while mandated both this specific layout, and these specific icons. The layout originated by the province of Québec trying to improve French keyboards, and was meant to find a balance between the original American-centric layout, and the needs of French language:

[The previous layout] prioritized English by putting every accented letter except é under two keystrokes. Glyphs that are far less commonly used like « and < were their own keys, but è and à needed two keys to be written. Francophones write à all the time. This was basically a remnant of typewriters’ operations brought forward to computers. The [new layout] moved most accented letters to their own key. Only the circumflex (^) [requires] two keystrokes, but that accent is the least used.

The effort started in the 1990s. Gagné reports that by 2006 it was deemed okay to use the layout, but forgo the special icons – that explains the disappearance of those unique symbols from Apple’s keyboards – and some time after that, the federal government withdrew the order forcing the layout, as well. (It is now only a “guidance.”)

Shining more light at the mystery, Gagné writes: “The anglophone majority in Canada never adopted this keyboard, so it’s seldom talked about in English.” (If you are interested in researching this more, the keywords are CAN/CSA Z243.200-92, SGQRI 001, and ISO 9995-7.)


Akira Yojimbo, on Masto, had a funny observation:

The argument that rounded corners reduces the clickable area of a button reminds me of the Mitch Hedberg joke that Kit Kat carving their name into each bar is robbing you of chocolate.


Lastly, Kevin Smith wrote this à propos updates, but it is also a good anecdote to follow the more recent post about Linear’s zero-bug policy:

I missed the deadline to submit mine, but here’s my folklore.org-type anecdote from my days at Apple: I personally wrote the novice-friendly Terminal warning about the sudo command in OS X. For the longest time, users were greeted with the 90s-vintage warning about properly using sudo: “We trust you have received the usual lecture from the local Systems
Administrator…” As an AppleCare support drone, I guided customers through a sudo command at least once per week, and always needed to reassure them about what this geeky text even meant.

Finally one day I filed a Radar (arguably something that was above my pay grade!) and provided a suggested revision to the sudo warning that was way less inside-baseball. To my utter shock, the Terminal team used my language word-for-word in an OS X update a few months later. I was never even notified that my change was used, it just appeared in Terminal!

As far as I know, the sudo warning was removed entirely from Terminal at some point. But as a low-level employee who never even worked in Cupertino, it was an honor for a few of my own words to live inside the OS for a number of years.


Thanks again!

“Because most users do not use dates before March 1, 1900, this problem is rare.”

There are really only three contenders for the most popular spreadsheet software: VisiCalc, the first computer spreadsheet and a system-seller for some home computers in the late 1970s, Lotus 1-2-3 dominating early PCs in the 1980s, and then Microsoft Excel (preceded very briefly by Multiplan). Excel dominated the market since the 1990s – so long it’s easy to assume it has always been there, but even hiding within Excel are some quirks of its predecessors.

One of them is documented in an official Microsoft Excel troubleshooting document:

When Lotus 1-2-3 was first released, the program assumed that the year 1900 was a leap year, even though it actually was not a leap year. This made it easier for the program to handle leap years and caused no harm to almost all date calculations in Lotus 1-2-3.

When Microsoft Multiplan and Microsoft Excel were released, they also assumed that 1900 was a leap year. This assumption allowed Microsoft Multiplan and Microsoft Excel to use the same serial date system used by Lotus 1-2-3 and provide greater compatibility with Lotus 1-2-3. Treating 1900 as a leap year also made it easier for users to move worksheets from one program to the other.

Yes, even in today’s version of Excel, you can easily get to Feb 29, 1900 – a date that never existed:

I find what follows in the same doc really funny, as you can sense perhaps a frustration of someone needing to answer this over and over again, or held to blame for the decision that wasn’t even theirs to begin with:

Although it is technically possible to correct this behavior so that current versions of Microsoft Excel do not assume that 1900 is a leap year, the disadvantages of doing so outweigh the advantages.

If this behavior were to be corrected, many problems would arise, including:

  • Almost all dates in current Microsoft Excel worksheets and other documents would be decreased by one day. Correcting this shift would take considerable time and effort, especially in formulas that use dates.
  • Some functions, such as the WEEKDAY function, would return different values; this might cause formulas in worksheets to work incorrectly.
  • Correcting this behavior would break serial date compatibility between Microsoft Excel and other programs that use dates.

If the behavior remains uncorrected, only one problem occurs:

  • The WEEKDAY function returns incorrect values for dates before March 1, 1900. Because most users do not use dates before March 1, 1900, this problem is rare.

But I also appreciate the details of what is a great example of bug-for-bug compatibility.

“We find many users write to us in a spirit of collaboration.”

From software company Linear, a blog post from last year titled Why we committed to a zero-bugs policy:

When we tell people that Linear maintains a zero-bug policy a common response is disbelief. It may sound like a ridiculous approach, but we do it because no other way makes sense.

The zero-bug stance means that we address bugs immediately, with the exact number of days depending on the severity: low-priority bugs need to be addressed within 7 days, high-priority bugs within 2. We formalized this approach two years ago. The impetus was actually a bug in a popular consumer app that I had reported to their team. Finally two years ago—and five years after I first reported the bug—I saw that it got fixed. I thought to myself, “wow, millions of users suffered through this bug for years for no reason.” If the company was going to fix the bug eventually, it would have been so much better to fix it right away.

That’s the big idea behind our zero-bug policy. We want Linear to be a solid, high-quality product, which means we’re going to address any bug that comes in. Fixing a bug takes the same amount of work whether we do it right away or put it off. But it’s not a zero-sum game: fixing it immediately gives us a higher-quality product and spares users unnecessary pain for the same overall effort.

It’s worth a read – especially if you’re a software quality process wonk – with some interesting observations on context switching and other things, for example:

I’ve heard stories of companies whose backlogs grow to thousands of bugs. Eventually, instead of fixing the bugs, they just delete the whole thing and start over. It’s a reflection of how when you put bugs in a backlog, in most cases what you’re really saying is you’re never going to get to them.

I also applaud the team for recognizing and pointing to the momentum boost and virtuous cycle on both sides – makers and their customers – when something gets fixed quickly after being reported:

It’s not uncommon for Customer Support to file a bug in the morning—often through our Intercom integration—and have it fixed by lunch. That kind of turnaround allows us to turn a bad experience—an encounter with a bug—into an excellent one that changes their whole perspective on what it’s like to reach out to a company when something is broken.

Over time these experiences have molded the way our user base reacts to imperfections in the product. Instead of coming to us angry or frustrated, we find many users write to us in a spirit of collaboration—working hand in hand with us to make Linear a better product because they trust we’ll respond quickly. It also often turns them into Linear advocates.

However, there’s one thing that feels unresolved. The post says “low-priority bugs need to be addressed within 7 days, high-priority bugs within 2” – but what if a bug cannot be fixed within these time limits? I can think of a few reasons:

  • a bug has a dependency on another, slower-moving piece of software (e.g. the browser or the operating system),
  • the fix is a bigger systemic or change management challenge that will take months if not years to complete (e.g. a keyboard shortcut change or an internal migration),
  • the fix requires a redesign larger than initially suspected,
  • the team disagrees internally on the fix and needs time to hash it out.

I know getting deeper into the weeds would not make for a nice post with a punchy ending, but I also think the system feels incomplete this way – as with every process, a careless application of a “zero-bugs policy” could fall prey to a sibling of Goodhart’s Law, as the team starts deluding itself into categorizing things as “not bugs,” or find other ways to avoid bigger challenges if they cannot be fixed within the given time limits. Black-and-white systems struggle with shades of gray, and I’d be curious what is Linear’s answer to tackling this tricky part.

“Yeah… I was very tired that night.”

The (un)installation bug from the previous post was an overeager directory delete, but a more common problem I’ve seen is this one. Here’s an example from iTunes 2.0:

The installer tries to erase a previous version of iTunes using (with root privileges) the rm -rf command. However it doesn’t take into account that volume names can contain spaces. […]

When the diskname (partition name) starts with a space the following happens:
rm -rf /Volumes/ harddiskname/iTunes.app 2> /dev/null

So rm removes /Volumes (all mount points!) and a nonexistent path harddiskname/iTunes.app, but no errors are displayed because they are /dev/​nulled.

And a very similar thing a decade later, from Steam’s Linux installer:

I launched Steam. It did not launch, it offered to let me browse, and still could not find it when I pointed to the new location. Steam crashed. I restarted it.

It re-installed itself and everything looked great. Until I looked and saw that steam had apparently deleted everything owned by my user recursively from the root directory. Including my 3TB external drive I back everything up to that was mounted under /media.

The culprit was identified by another user a few messages down:

rm -rf "$STEAMROOT/"* could be evaluated as rm -rf "/"* if $STEAMROOT is empty

These are the sort of classic user-generated content meets string concatenation/​interpolation bugs that haunt engineers’s dreams.

The solution: If a user gives you a string, you have to wrap it as safely as possible so that it could never break apart into pieces in transit.

So you wrap the path with quotation marks. (I believe you can actually do this everywhere in Linux – cd "/usr/local" will work as well as cd /usr/local – except no one ever does so as it’s quite annoying.) But then, a string with quotation marks would escape containment, so you have to escape those by changing " to \". And then, naturally, you also have to escape any freefloating backslashes to \\.

Of course, there are usually functions that take care of all of the above; you just have to remember to use them, as well as think about the edge cases like a variable being empty to begin with.

This all is a distant version of SQL injection – perhaps most well-known from this XKCD comic – and a more modern prompt injection. There’s even a version of it in UI design:

Here, the wrapping isn’t for security reasons, but to help people understand where the command ends and the string begins. But this introduces a new challenge, as any type of visual wrapping – quotation marks, bolding, italicization – can draw undue attention to the string itself. So, sometimes you just leave it be and hope for the best:

But let’s go back to the installation issues. I bet there are were tons more string interpolation and escaping bugs that we simply never learned about. Yet, as users of a project called Bumblebee learned in 2011, nothing beats the destructive power of a simple typo.

The best way to start here is with the summary of the fix to the bug, because that is the best encapsulation of the story:

Yeah, you read it right.

Here’s the original bug report:

An extra space at line 351:
rm -rf /usr /lib/nvidia-current/xorg/xorg
causes the install.sh script to do an rm -rf on the /usr directory for people installing in ubuntu.

Totally uncool dude!!! The script deletes everything under /usr. I just had to reinstall linux on my pc to recover.

Removing the space will fix this. Probably should do it quickly!!!

Reader, the bug was fixed quickly.

“But it would have bothered us the rest of our lives.”

On the morning of December 28, 1998, the day before the game Myth II: Soulblighter was supposed to hit the store shelves, the publisher received a phone call:

[…] one of Bungie’s overseas publishers called to say that a woman had played the game and then tried to uninstall it. The game software had uninstalled Myth II as it was supposed to--but it had also erased some of the other files on her hard drive.

The first reaction was panic […] [Bungie cofounder Jason] Jones and another programmer tried to replicate the problem. They quickly found it and figured out how to correct the faulty lines of code. Fixing the problem would be easy—except for the 200,000 copies that were already packaged or on the road.

Seropian, Jones, Zartman, Donohue, and sales and marketing director David Joost met to decide what to do. They had two options. The first was to say nothing. The argument in favor of this alternative was that the problem occurred only when the program was uninstalled and then only when someone had installed the game in an unconventional way to begin with. Since the chances were slim that anyone would install the game in this weird fashion and uninstall it right away, the risk to the company’s reputation was minuscule, particularly since they could post an announcement on their Web site along with a free patch that could be downloaded to correct the problem.

The second option was to recall the game. That would force them to trace every copy that had already gone out, scrap every finished copy, and start all over again.

The story continues in a Chicago Reader article by Bill Mahin preserved on Internet Archive – there’s a blizzard and other things going wrong – and is a great callback to the days of software being sold as physical media, in physical boxes.

I was curious about the cause of the bug, and found this answer from someone who worked on the original Myth I:

So I wrote the Myth TFL installer (not this one). The reason this happened is because you could install other maps and whatnot, and to make the uninstall clean, we had to recursively delete your data folder.

In the sequel, somehow that code […] was used to delete the applications directory, instead of just the data directory in the applications directory. So if you installed it on C:\, it would delete everything recursively from there.

Nowadays, uninstall usually leaves any user installed files (like saves or downloaded content) but at the time, as the article suggests, hard drive space was more precious. Also, I wasn’t there for this issue, so I don’t know the above for sure, but having written the previous installer, I’m pretty confident that’s what happened.

“I want to release it, even if the quality would be a little lower.”

In 1996, Street Fighter Alpha 2 was ported onto Super Nintendo Entertainment System, a 1990 machine on its way out and not really up to the task of running such a modern game.

The team put up a hell of a job, involving adding a custom compression chip, with the game being much better than anyone expected – but still suffering from a big flaw, which was a momentum-breaking 3-second freeze at the beginning of every battle.

Dimitris Giannakis, also known as Modern Vintage Gamer, describes the problem and community’s more recent efforts to fix it:

Turns out, the problem wasn’t the compression chip, but sound effects – and the fix to complelty remove the delay relatively trivial in hindsight. A community member named gizaha posted a patch to the game in 2020, and its description can send shivers down your spine:

  • Disable some waste sample loads

Sounds good.

  • Tweaked audio engine for faster start of loading

Alright, fair enough, perhaps the game was rushed to market and some light optimizations skipped.

  • Faster audio load, upload 2 bytes at the time instead of 1

Oops.


Also in 2020, people set their sights on another 1990s game, Super Mario 64.

MattKC on YouTube talked about a similar problem as SFA2 – the game seemingly wasn’t properly optimized:

For years, if not decades, this has been accepted as fact: Bowser’s sub is just too big and too goofy for the N64 to draw consistently. But what if I told you it didn’t have to be?

Nintendo just… forgot to turn on a C compiler optimization feature before shipping the game. The result wasn’t as egregious as random 3-second freezes, but still gave people much lower framerate on certain levels:

However, Giannakis followed up on that, and discovered the story wasn’t as simple. The optimization in question was still itself evolving at the time, and had known issues when Super Mario 64 was being developed. As easy as it is to turn it on in 2020, all polished and tested, it was a different story in 1996:

The video actually compares the versions visually, and even investigates other optimizations.

But it all pales in comparison to this 2024 video by Kaze Emanuar, who says “hey, guys, you have been looking at the wrong place the entire time” – as a matter of fact, it wasn’t the optimizations that Nintendo didn’t turn on that made the game slower. It was the optimizations they added:

The video is kind of intense, but I feel you can learn a few really interesting things from it:

  • how you show the debug information matters,
  • there is such a thing as a “performance lottery,”
  • naïve efforts to optimize can be heavier than not doing anything at all,
  • it’s best to optimize for maximizing minimum frame rate, rather than average frame rate.

It’s a fascinating watch, suggesting framerate increases of up to 50% on the original hardware, with just software changes.

Both the Street Fighter 2 Alpha and Super Mario 64 efforts also portray a terrifying notion: imagine your code being hyperanalyzed by a group of people 25–30 years later, pointing at your flaws.

The Swiss Cheese model, pt. 3

After two more serious posts in this series, I wanted to stop somewhere a bit more lighthearted and inconsequential.

“Here’a a fun thing you can try,” begins this 13-minute video from Retro Game Mechanics Explained:

The premise of the parlor trick the video describes is a bit convoluted:

  • Get your Nintendo Entertainment system, put in the Mario cartridge, and power it on,
  • without powering it off, grab the cartridge and replace it with the Tennis cartridge,
  • start the game, wait until the music stops, then move around for a bit,
  • take that cartridge out and put Mario back in,
  • press A+Start and you will see that you will start at a random “invalid” level that doesn’t exist, which should not be possible.

I’ll let you watch the video for a nice explanation, but this I think is a good example of the Swiss Cheese model:

  • A+Start is real feature that allows you to continue the new game at the last level you finished (as opposed to Start, which always goes to Level 1).
  • The NES allows you to take the cartridges out and put them back in while the machine is under power.
  • The creators of Mario decided to make the game reset itself on every game over, and differentiate between cold boot and warm boot in a specific way.
  • Tennis doesn’t wipe the memory on start.
  • Tennis happens to change the memory in a very particular way that ends up being accidentally “compatible” with Mario.
  • The Mario game doesn’t sanitize the level number on entry, so you can start on an invalid/​broken level.

Just like before, the absence of just one of these Swiss Cheese holes would prevent the bug from happening. But the holes line up perfectly.

I found this whole thing kind of fun and delightful, and I actually understood why the creators of Mario decided to reset the game (with a small exception) on every game over – it’s brutal but elegant, and something I found myself wishing was easier to do during various projects I worked on in the last few decades.

Of course, there might be an argument that this is such a highly manufactured scenario (how did anyone even find that out to begin with!?), and of limited value, particularly if you end up at a random level anyway. We will pull on that thread in a future post, because the story doesn’t end here. People who spend time hacking old games go way further than this.

“The ghosts are fast and they don’t turn blue.”

Some time ago, I shared a video talking about games that leaned into their bugs and made them part of their lore.

One not listed there, perhaps because it’s the most obvious example, is Pac-Man’s kill screen.

A few weekends ago at an arcade game convention, I spotted something really interesting. It was an arcade cabinet of Pac-Man, but with a twist: The game was modified and set up to start immediately at level 255, with all its challenges: fast timing, very angry ghosts, ineffective energizers.

And once you beat that, you immediately face level 256: the infamous kill screen.

I don’t think I have ever seen anything like this before. It reminded me of this joke someone made once about the olympics: that each competition should begin with the organizers grabbing regular people from the street to participate, just so the viewers can truly realize how impossibly hard those competitions are.

I know a lot of software onboarding starts gently, walking you through basic scenarios to make you comfortable and to have you understand basic concepts. But sometimes I wonder: for professional apps, would it also be cool to start with a really advanced use that would get you excited? A really well-made, complex spreadsheet? A really sophisticated graphic? Instead of gently propping you up, what if the onboarding was about breaking something really complex down?

I played the game a few times. I didn’t finish the level 255, and I never saw the kill screen. But it was a great challenge; if I had more time, I’d definitely spend it trying to make it happen.

The Swiss Cheese model, pt. 2

1.

Oh damn, you caught me in the middle of something. I was just trying to make a list of Windows versions for a friend – in Google Docs, of all things.

Should be easy. I already grabbed this one off of Wikipedia and massaged it a bit, but it’s still kinda ugly:

I don’t love the tight padding here. Let me try something bigger, like 0.08 inches? I’ll just select the first column and punch the number in, and…

What the hell!!!

Jesus. What happened? Okay, let’s press ⌘Z to get out of it…

Oh, no. Maybe I can press Esc…

Shit.

2.

Okay, here’s what happened in precise detail:

  • I pressed Backspace to delete an existing zero:
  • I started to type “.08”. Pressing “.” was okay, although it showed a pretty thirsty tooltip:
  • upon adding “0” Docs removed the “.” and so the output was just “0”:
  • upon adding “8” Docs removed the leading zero and we ended up at just “8”:
  • the page saw the resulting “8”, applied 8 inches of padding (a hundred times of what I wanted!), and just showed it to me in real time, resulting in a profoundly unrecognizable table that looked like something went horribly wrong,
  • pressing ⌘Z didn’t do anything,
  • pressing Esc only removed the focus from the input field.

I believe I can explain exactly the chain of reasoning and bugs here:

  • To start with, any number entered is immediately previewed on the left. This generally feels good!
  • Instead of fixing my input on commit (Enter), the input is being rewritten on the fly, as I’m typing. This wouldn’t be my recommendation, but I can understand this design decision.
  • If I typed just “08,” it would be rewritten to “8”. This makes some sense since it normalizes the numbers, and makes them consistent.
  • If I typed “.1”, it would be rewritten to “0.1”. Sure, fine, a similar idea.
  • However, typing “.0” rewrites it to just “0”. I believe this is a bug or a lack of imagination – it should be rewritten to “0.0”.
  • ⌘Z doesn’t work. I believe this is a bug where system’s rewrites of numbers don’t put the change on the undo stack. (As a matter of fact, it appears worse than that – pressing ⌘Z a few more times ended up rewriting my number to “80”, which would have made this even worse!)

So, in effect, my “.08” got mangled to “8”, applied immediately, and wasn’t easily undoable.

3.

This feels like a great example of the Swiss cheese model in action:

If just one of these bullet points below behaved differently, I would not end up in this situation:

  • with numbers not being rewritten on the fly, there would be no problem,
  • with “.” not be aggressively rewritten to “0.”, there would be no problem,
  • without live preview, the rewrite could’ve been caught and fixed it by hand, instead of panicking seeing a huge change on the screen that felt like data loss,
  • with a fully functioning input field undo, the moment of panic could be reverted,
  • with Esc to abort instead of commit, likewise.

All of these decisions made sense and didn’t feel dangerous or important in isolation. Together, the holes in cheese aligned perfectly, creating a pretty scary experience.

Thank you to Ezra Spier for sharing this with me.

A bug becoming a feature (1972 edition)

I just learned something fun this weekend. The seminal videogame Pong from 1972 looked like this:

But there was a problem. Here’s Al Alcorn, the designer/​engineer of the machine:

The paddles on the original Pong didn’t go all the way to the top. There was a defect in the [circuit] – I used a very simple circuit, I had to, to make the paddles, but they didn’t go to the top.

This meant that there could be situation where the ball sneaks up past the paddle at the very top of the screen, and the player cannot do anything to stop it.

You can see it in this video:

But Alcorn decided not to change that:

I could have fixed it, but it turned out to be important, because if you get two good players they could just volley and play the game forever. And the game has to end in about three or four minutes otherwise it’s a failure as a game. So that gap at the top, again – a feature. So that was sort of a happy accident.

“Happy” primarily in the context of the industry – the goal of an arcade game was, after all, to bring in quarters, and this here was the unexpected equivalent of the zero in a casino roulette game. But I wonder if some of this bugginess/​randomness also helped the game feel challenging and surprising, even for skilled players.

“Something seems to be going crucially wrong with the frame rate.”

Let’s Game It Out is a YouTube channel where Josh Knoles occasionally grabs a modern videogame and tries to play it in a particularly creative way – finding bugs, breaking things, doing an action more times than anyone thought possible. What makes it even more fun is that what’s tested often are early access, unfinished games. Here’s an example 27-minute video of a game called Parking Tycoon:

There are many more. I could tell you that occasionally putting one on teaches me something about bugs or lets me put myself in the mind of a very inventive user. Sure, occasionally, perhaps. But mostly these are just fun to watch.

“Try quickly typing 1+2+3. I bet you won’t get 6.”

Earlier this month, I talked about a rotation button in photos that behaved really nicely in iOS, and not so great on the Nothing Phone. Here’s a story of a similar fumble iOS once made that might bring the point home even more.

The calculator app has been preinstalled on iPhones ever since their debut in 2007. For the longest time it hasn’t been anything more than a standard four-function calculator with a decades-old feature set. If you’re not careful, however, you can mess up even that.

Ten years into iPhone’s history, iOS 11 introduced a problem just like the Nothing Phone rotation – quickly tapping on keys would show them as responding, but the actual action wouldn’t be registered. Michael Tsai’s aggregator’s first entry has a video from Stephen Heaps:

It shows typing 1+2+3+4 where iOS forgets one press of +, resulting in 1+23+4 = 28. Many more people posted about it afterwards, and showed various other examples.

It is oddly enthralling to see a computer fail at basic math. But what’s particularly historically interesting and perhaps even more embarrassing for Apple is the absolutely rich history of solving this kind of a problem.

Calculators evolved alongside typewriters as the earliest devices with button-like (as opposed to piano-like) keyboards. But the stakes were different.

Imagine a badly constructed typewriter and all the ways it can disappoint you: the letter might be faint if you press the key lightly or puncture the paper if you press it too hard, the output might be misaligned, or the typebars will jam in some way, forcing you to go again.

A typewriter has to work hard to divvy up a blank, analog piece of paper into a reliable, pleasant-looking grid via escapements, ratchets, and so on. But a calculator’s work to convince the analog world to be digital was much more important. After all, it’s not likely that the typewriter key you pressed will output the wrong letter – but on a badly constructed calculator, a light press of 5 could absolutely output 4, or 6, or 4.5.

And, while the typewriters only take your words verbatim, the calculator’s job is precisely to create new numbers out of the numbers you type. An imprecise mechanism can mess up that math. A jam could perform a partial or nondeterministic calculation. Adding 1 to 999,999 and the force necessary for the resulting cascading carry could break a device in the middle of work.

On top of all that, languages have a built-in redundancy. Evn if yuo mak many typoes, th sentece can stil be understod. But all numbers basically look alike. A calculator could make a mistake when it comes to a number that is absolutely vital for your payroll, for engineering, or for navigation – and you would never spot it.

Understanding all this, many calculator makers even already in the 19th century spent a wild amount of effort convincing people not just that their devices were helpful, and fast, and easy to use, but also that they could be trusted. Buttons were carefully weighted. Comptometers came with a locking mechanism. If a machine felt something didn’t go right, it would stop working and require a hard reset. The message was: “You can trust me, because I won’t ever show you bad math, and I’ll stop myself before I will ever lie to you.” Charles Babbage was so confident in his Difference Engine that he welcomed people to try to mess with its mechanical wheels in the middle of the calculation, convinced that even a sabotaged machine won’t ever make a mistake.

Just like with the Selectric decades later, those things were solved by people who cared, in the much harsher mechanical conditions.

Of course, I don’t expect everybody at Apple core iOS team to be a calculator UI historian (although it would be nice for at least one person on the team to be one!). It is embarrassing that no one on the team had enough imagination to realize that making a button respond to a quick press during animation, but not register it would cause all sorts of serious trouble. (The bug was fixed in iOS 11.2 by removing the animations, and subsequently the animations were brought back without the original problem in iOS 11.3.)

But maybe the bigger embarrassment is that Apple didn’t have a battery of tests to run on top of the UI at various speeds, mimicking fingers of what must be millions of people using the calculator app. That, too, has been a standard procedure for decades.

Those tests seemed missing in 2017. I hope 2+3+4 years later that’s no longer the case.

The Swiss Cheese model, pt. 1

Have you head of the Swiss Cheese model? You see it sometimes in descriptions of how complex systems fail. The visual usually goes like this:

The whole idea is: even if you have multiple layers of safety – like many slices of cheese – there are always holes in each slice. Typically, a hole in any slice is covered by a non-hole in the previous one or the next one. (For example, a car might not allow you to grab your keys if you have not shifted to park – or, if you start driving with a handbrake on by accident, the car might yell at you.) But occasionally, the holes just happen to line up, and a larger disaster strikes.

The model is used in analyses of past accidents, and prevention of future ones. It has proponents and detractors. It’s hard to talk about its applications because the most common examples are horrific. In my book, I wrote about Therac-25, and that was a really unpleasant chapter to research and to write. Other go-to case studies are equally bleak: Chernobyl, Challenger, the Tenerife airport disaster, the Deepwater Horizon explosion.

But I wanted to share it because in my head it applies to UI design also, and sometimes helps me think of how small details add up to a larger whole.

In this first part, let’s start with a more traditional example, although a non-drastic one. Here’s a story of Knight Capital Group, a financial services and trading firm. I’m going to hand off the summary of the accident to Henrico Dolfing:

On the morning of August 1, 2012, Knight Capital Group opened its systems for what should have been a routine trading day, yet within minutes the firm began sending a flood of unintended orders into the U.S. equity market, buying high and selling low across dozens of stocks in a pattern that made no economic sense and could not be stopped through normal controls. What initially appeared as unusual market activity quickly escalated into a systemic failure inside one of the largest market makers in the United States, with algorithms behaving in ways that neither traders nor engineers could fully understand in real time. […]

By the time the issue was identified and the system shut down roughly 45 minutes later, Knight had generated more than 4 million executions across 154 stocks, covering approximately 397 million shares, and accumulated positions worth billions of dollars, resulting in losses of more than $460 million […]. The scale of the incident was not only financial but structural, as a single deployment failure had propagated through a system responsible for a meaningful share of U.S. equity trading. […]

Here’s what happened.

Long ago, the firm built a pretty boring function called Power Peg to automate some transactions. The function used a standard shared limiter that made it stop executing when all the required transactions were fulfilled. After some years in use, the function was deprecated in 2003 and stopped being used then, but crucially, the code was never actually removed.

Some time in between 2003 and 2012, the limiter functionality was upgraded, and the old code stopped being compatible with it. All code in production was rewritten to use the new limiter, but the Power Peg feature wasn’t, as it was already deprecated and not in use.

In 2012, the firm started writing a new program for automated transactions. Its creators decided to reuse the same software flag that previously activated Power Peg. The existence of the old code was known at the time, and the idea was that the code would be overwritten by the new program, so the reused flag would only trigger new code.

In July 2012, the new code was finished and the firm started to install it on all the servers, overwriting Power Peg. The firm intended to deploy the new code to all eight servers, but a mistake resulted in it only arriving on seven servers.

No one caught that mistake.

At this point, you can piece it all together. At this point, I imagine many of you have been wincing more and more with each passing paragraph.

On August 1, the flag for the new functionality was turned on. Everything was fine on seven servers, but on the eighth one, the flag reawakened dormant code that immediately started executing. As the old code was not compatible with the new limiter, it was never limited, cascading into millions of transactions in less than an hour, and a lot of collateral damage; the subsequent market reaction to the news of the firm losing over $400 million and caused its own stock to tank.

Oh yeah, I didn’t mention this yet – the failure killed the firm. (Well, it resulted in a merger, but that seemed to be a way to save face after Knight Capital Group almost went under.)

How does the Swiss Cheese apply to this? You can see it as five holes in five different slices of cheese:

  • it was a mistake to not actually remove the old code
  • it was a mistake to reuse the same flag
  • it was a mistake to not deploy to all 8 servers
  • it was a mistake to not have a procedure for someone to double check the deployment
  • it was a mistake to not have a way of auto-detecting (and perhaps auto-stopping) the runaway processes when the regular limiter failed

What’s important to understand about this model is that either of these in isolation would objectively be a small mistake, and caught by the other slices. As a matter of fact, any four of these happening would still not add up to a catastrophe.

But in this case, the five mistakes lined up perfectly.

Many analyses of such accidents blame a single event in the chain – in this case often the sysadmin that didn’t deploy the code to eight servers properly – but this is primarily because we like stories of individual agency, and are not well equipped to understand stories of systems. (Even Star Trek added a Borg Queen.)

That’s the accident eventually dubbed “a Knightmare.” More examples of systems closer to our hearts in following parts.

“Cursed knowledge we have learned that we wish we never knew.”

Immich is a self-hosted photo/​video app, and one of their side pages is Cursed Knowledge:

Cursed knowledge we have learned as a result of building Immich that we wish we never knew.

There is something about this format that I really enjoyed as a reflection but also as a way to share with others – simple one sentence/​paragraph updates with links, so you can inhale quickly but also go deep if needed. There’s some overlap with bugs here, but it’s not necessarily only buggy stuff – also quirks of formats, observations, etc.

I made a cursed knowledge page for Unsung – let me know!

Thanks to Casey Gollan for posting about the original page.

“The root of all margin-collapsing evil”

I liked this page I just learned of called Incomplete List of Mistakes in the Design of CSS. It might not mean much to you if you don’t write CSS, but could be fun to check out if you do. Here are some choice quotes:

  • border-radius should have been corner-radius.
  • It shouldn’t be !important — that reads to engineers as “not important”. We should have picked another way to write this.
  • white-space: nowrap should be white-space: no-wrap.

It reminded me of a similar list called Known Anomalies in Unicode Character Names. Here’s one example:

U+02C7 CARON
U+030C COMBINING CARON

The “caron” should have been called hacek and combining hacek. The term “caron” is suspected by some to be an invention of some early standards body, but it has also been claimed by others to have been in use at Linotype before the days of digital typography. Its true origin may be lost in the mists of time.

These are great because they simply say “this is how we messed up.” They are succinct and candid about problems. More work needs to be done at this point, of course – the CSS list only really contains the “simple,” low-level observations, and I think for both CSS and Unicode fixes cannot simply be made because people and systems rely on the existing behaviour – but the first step is admitting you have a problem, right?

If you’re on the outside, it can be comforting to realize “oh, it wasn’t just me, other people don’t like this, too.” (Scanning bug reports from other users can help in a similar way.) If you’re on the inside, consider making a list like this for a long-standing project. It might do you or your team good!

If you are aware of more documents like these, I’d love if you could send them over.

“No one knows who patient zero was.”

If you stepped into the dwarven capital of Ironforge on September 13, 2005, you would find only bones. Lots of bones. The city, along with every other major population center in World of Warcraft, had been ravaged by a plague that slaughtered players by the thousands, their bleached bones covering every street.

This is the beginning of the retelling of one of the most infamous bugs in videogame history, written by Steven Messner in 2019. It’s a surprisingly thrilling read.

The TL; DR of the whole issue is that during a specific special event in World of Warcraft featured a big bad boss who actually stole blood off of players to replenish his own health. The fun narrative idea was that players were meant to infect themselves with a virus called Corrupted Blood, to trick the supervillain into getting infected, too.

Things worked well except… the virus escaped containment.

“The corrupted blood was an effect and the designers forgot to clear it off your pet, so if your pet got despawned while it was in the encounter, it would save your pet with corrupted blood on it. The next time you summoned your pet there was no code to go «Oh you’re not in the raid, we should get rid of the corrupted blood.»”

If this reminds you of something, yeah, RuneScape had a similar incident a few months later in 2006. Here, it was also similarly tricky for the developers to figure out how to restore order:

“Our choices were either to go through every pet in every server in every country in the entire world and check if it had corrupted blood and get rid of it, or get really hacky code in where every time you summoned a pet it would check and see if it had corrupted blood on it and get rid of it.” […] Despite numerous hotfixes, it was nearly a month until Blizzard fixed the problem completely by making it impossible for pets to contract the disease.

The disaster had a few interesting codas. The first one was that World of WarCraft and other games eventually started occasionally introducing an epidemic – now 100% intentional – as special events in their games.

The second one? The accidental in-game event helped researchers understand actual real-life epidemics. As summarized on Wikipedia:

Of particular interest to researchers in the use of MMORPGs for epidemiology is that character responses to a virtual pandemic are the result of individual player reactions, adding “a level of authenticity that doesn’t exist in other simulations”. Disease researchers typically study disease spread and control through the use of three general models, all of which make significant assumptions about human behavior. As behavior is difficult to predict, the effectiveness of these models is limited.

Mailbag: The curious case of the disappearing Polish S

Even before the “remaster,” my essay about the Polish S bug was routinely discovered by Hacker News and other places, so I thought I would take a look at all the commentary over the years and summarize.

First, pragmatically, these are the lessons for any keyboard shortcut designer:

  • On Windows, AltGr (Right Alt) and Ctrl+Alt shortcuts are one and the same, and Right Alt and alphabetic keys are used for some languages to output regular accented letters. You should not prioritize Ctrl+Alt shortcuts anywhere your users write text.
  • On a Mac, ⌥ and most keys generate characters. They do so even on English layout for extra typographical flair, but particularly in other languages, regular accented letters might hide there. Note that these are not just letter keys, but also digits and other keys. You should not prioritize ⌥ shortcuts anywhere your users write text.

I couldn’t find a good image, so I made these two as an example. First is Mac’s American keyboard with ⌥ held. Second is Polish keyboard with ⌥ held, with Polish letters highlighted:

Jumping to the promised comments, I liked this story:

Outlook has a shortcut Alt+S to send the current e-mail. In Polish “Hello” is “Cześć”. When you acidentally have non-Polish locale enabled and write “Cześć” in Outlook - you send “Cze” as your whole e-mail.

“Cze” is a very informal greeting, sth like “Yo”. There has been thousands of such e-mails in Polish companies sent to people who really shouldn’t be greeted with “Yo.” :)

Here’s a little summary of other similar bugs. I verified some of them:

  • “Oh, that explains why I accidentally triggered Claude with Alt+Space, despite it being configured as Ctrl+Alt+Space.” Link
  • “Noticed similar issues with official Australian VISA / immigration pages. You can’t simply fill some forms with your email address using Finnish keyboard. Why? Because they block usage of AltGr button on their page. They also prevent using clipboard blocking copy paste option for that sign. User has to be smart enough to switch to US keyboard and then enter @ sign and then switch back. So this is nothing new, but it’s absolutely rude from part of the site designers to vandalize basic functionality like that. Normally @ is produced by AltGr+2.” Link
  • “In a similar fashion, you cannot type the capital letter Ł in Notion. You type the letter with ⇧⌥L on the Polish keyboard on a Mac. Notion uses the ⇧⌥L keyboard combo for its own purposes.” Link
  • “Medium learnt its lesson in 2015. Google still hasn’t and you cannot type Ś in Sheets, at least not on MacOS.” Link
  • “Meanwhile, in 2026 I suddenly cannot type capital Ś in Edge on Mac. I feel like I moved back in time 25 years or so.” Link
  • “I wonder if it is a similar reason why currently on MS Teams I can’t type the letter ń.” Link
  • “It’s just like the new Copilot 365. Every time I try to type Ć, Copilot pops up. I have to close the app constantly.” Link
  • “I had a similar issue when ASUS’s bloatware background service decided to bind something to both Alt+S and Alt+A globally. I have to keep it disabled or else I won’t be able to type ą, Ą, ś and Ś without using Caps Lock to work around the issue.” Link
  • “In an Nvidia overlay there is a shortcut Alt+Z. It’s pretty annoying because it triggers on both left and right Alt, so polish users cannot type letter ż without opening the overlay or rebinding it. Nvidia pls fix.” Link
  • “The very same bug used to be present in early Windows mobile GPU drivers - with global hotkeys making it impossible to enter Ł (with Intel GMA 950) and Ć (with ATI Catalyst). Being a Polish geek, I used to earn lots of free dinners from frustrated friends who were forced to copy-paste those letters on their brand new laptops. Funny how the same bug recurs in different types of software due to an obscure locale-dependent edge case - and it’s much less known than, for example, the Turkish dotted/​dotless I.” Link
  • “Installing KeePass used to silently disable ”ą” key (AltGr+A hotkey). KeePass broke system of every Polish user immediately after being installed.” Link

I’m sharing this for awareness. I believe many other languages/​writing systems also have this problem; the examples are lopsided toward Polish only because my original example was about Polish.

Lastly, I found this an interesting anecdote:

In Portugal we had a similar workaround in the early days of computers not supporting our alphabet properly. Like in Polish there are plenty of words that without diacritics get another completely unrelated meaning, e.g. caça vs caca, which you didn’t want the interpretation to be left to the receiver.

So tricks got invented, like adding additional letters for the missing diacritics, é becomes eh, è becomes he or eh as in the former case, the example above would be cac,a and so on. However it was still quite flexible, not everyone uses the same extension set.

I wouldn’t be surprised if every single language outside of English developed some sort of a way to cope and adjust to limitations of originally American-oriented computers. In my book, I wrote about Japanese and Turkish, and there is another book – The Chinese Typewriter – that spends a lot of time talking about this very issue for China.

If this subject is particularly interesting to you, venture out into the Hacker News waters to see more commentary: 2015, 2021, 2024, 2026.

“I kept getting trophies and was wondering how that was possible in a demo.”

There are tons of small bugs around. Occasionally, there is a really big one. In the “oh my god, I can’t believe it” category, here’s a story of the game Yakuza 6.

A few months ahead of launch, in February 2018, Sega released a free playable demo of the game. The demo gave access to the first level, and then blocked the progress with a barrier:

Somewhat unusually, the demo actually contained the entire game in a hefty 35GB+ download. The idea was apparently that after the game release and player’s purchase, they could “unlock” the game with a code and resume as if nothing happened, instead of downloading it separately and likely losing their progress. However, that made this barrier a pretty load-bearing one, as finding a way to circumvent it would mean people could play the entire game for free.

But before speedrunning hackers laid their hands on this challenge, it turned out no circumvention was even necessary – a bug in the game code itself made the barrier simply not appear on American PlayStation consoles.

Sega realized it quickly, pulled the demo, and blocked the installed copies via DRM, but not before some players got access to the complete game and finished more than the expected first chapter.

Alas, there was no public post mortem or an explanation; I’d love to understand what happened on a technical level. Either way, it’s wild trying to imagine the moment people at the company realized what they’ve done.

A mixed blessing

The otherwise excellent note-taking app Bear has an interesting bug that’s worth talking about while it’s still here.

When you’re around to-do items, you can press ⌘. (period) to toggle any task complete or incomplete. It’s actually a really fun shortcut in practice:

But when you have a larger selection with a mixed state (some checkmarks are on, others off), this is what happens:

This feels like an obvious thing to implement, and this is also where the code itself wants to go when left alone.

But this is not great. The rule is: When you have a mixed state, changing it should collapse (or: normalize) the entire selection to one state or the other, rather than perform individual inversion. Try ⌘B in your text editor on partially bolded text, and you can see that collapse in action:

It feels strange to recommend that, particularly as it seems like it loses data. So, what gives?

The first argument is “do not make the user jump through hoops” or maybe “respect a large selection.” If, as a user, I want to actually make sure all my tasks are done, the shortcut not being idempotent means that I now have to go through tasks one by one, and that’s a lot of work – especially since we’re talking about text selection, which is famously unpleasant.

The second reason is that even the UI layer has an opinion here. In the above bolding example, Pages collapsing the selection to bold when you press the B toggle, makes the toggle UI behave exactly as it normally would with a simple selection:

Elsewhere, in Figma, typing a number on top of a “mixed” state changes all the properties of relevant objects to that number:

Imagine how awful it would feel mechanically in both the above examples if your action would still leave the text in the “mixed” state. It would simply appear like the UI broke, since the change didn’t fully “stick” – kind of like those tiny hated moments when you close the door, but it doesn’t latch on and reopens on its own, or when you engage the turn signal stalk, but it refuses to stay put and snaps right back.

There is also one last reason. It’s the simplest one that I sometimes have to remind myself to put in my head before I jump too deep into the mechanics, or details, or technical nuances. Let’s say the toggles invert individually on a large selection. Who would ever benefit from it behaving this way?

“But obviously, that’s just silly stuff.”

This 22-minute video by Karl Jobst describes a pretty wild discovery of a glitch called Crystal Storage Glitch, allowing to skip a certain level for much faster completion times in Mega Man X2:

I won’t spoil the glitch because it’s a fascinating combination of a corner case, a race condition, and even a dose of dumb luck. Its finding unveils almost like a scientific discovery over many years – first a theoretical possibility, then a first sighting done in a modified emulator, then confirmation made by a machine via a tool-assisted speedrun, and eventually actual performance by someone by hand. And a lot of this achieved by relative newcomers to the community, too.

There is certain poetry here in having to go slow to go fast – you’ll see what I mean.

FAIL_​MAIL_​OVER_​500_​MILES=TRUE

Here’s a 2002 story from a younger internet, by programmer Trey Harris (link to the original and if you don’t like the classic Usenet formatting – my browser’s reader mode can’t even prettify it! – here’s a nicer-looking format):

“We’re having a problem sending email out of the department.”

“What’s the problem?” I asked.

“We can’t send mail more than 500 miles,” the chairman explained.

I choked on my latte. “Come again?”

“We can’t send mail farther than 500 miles from here,” he repeated. “A little bit more, actually. Call it 520 miles. But no farther.”

It would be easy to assume this is a classic case of pebkac, “problem exists between keyboard and chair,” the derisive term used (supposedly!) by support people, describing naïve public who had a tenuous grasp of technological reality. But the story goes to an unexpected place.

This might be the most widely-shared computer bug story of all time I’ve seen – I just saw a comment from 2008 calling it “oldie but a goodie,“ and it even has an FAQ page that’s actually a really great read. There’s quite a bit of chatter inside about something important to me: the balance between the needs of good storytelling and going deep into technical details:

In the story, I make it sound like it took all of ten minutes from being made aware of the 500-mile email limit and determining a 3 ms light-speed issue. In fact, this took several hours, and quite a bit of detective work. The point is, eventually I came up with that figure, ran units, and gagged on my latte.

You can sense author’s frustration with every nerd trying to “gotcha” him instead of just enjoying the story. Even a younger internet wasn’t without faults.

“Some say it sounds like an alto saxophone.”

I witnessed this Siemens locomotive depart yesterday and for a second I thought I was losing my mind. Then, I smiled so hard:

Turns out, the startup melody was intentional in this particular model. The power converters have to adapt the current from the overhead line to convert it to the three-phase motors of the locomotive, and that generates a rising tone. The engineers decided to change the logic to increment the tone in precise few steps resembling a musical scale, rather than allowing it to rise continuously.

I debated whether to include this on Unsung. I guess it is software, even if it’s attached to the hardest of hardware. And sure, it’s “just” delightful, but it is still kind of nice to see someone go extra, adding a human touch atop a technical process that had to happen anyway.

But then, it reminded me of something. No, not the poor CSIRAC trying (and similarly struggling) to become a musician. Rather, a “musical road” built in Lancaster, California, where the engineers messed up the execution, creating a truly unpleasant, atonal melody. David Simmons-Duffin wrote a fun essay in 2008 analyzing the “bug” thoroughly, including useful visuals, and even replicating the problem. Subsequently, Tom Scott visited the road and made a video about it ten years later.

It won’t surprise you that the cause of the bug was bad hand-off between designers and engineers, but there can be no software patch for grooves you cut in asphalt – and so at least as of last year, the embarrassingly sounding road was still there.

I think I prefer my out-of-tune musical scale performed by a train. Given it’s easy to find compilation videos of Siemens locomotives booting up, it seems I’m not alone.

“Accents are an opportunity, not a burden.”

The iOS 26 update introduced a bug in the Czech keyboard. Instead of the customary háček (ǍǎĚěǦǧǏǐǑǒǓǔY̌y̌) in the bottom row, another key was duplicated, removing access to the accent character (or, a diacritic) very popular in that language.

Here is the before and after of this situation:

Ordinarily, this can be frustrating but not insurmountable; you can always copy/​paste, rely on autocorrect to help out, or even add some topical text replacements for common phrases. The problem is that this bug only appeared on the keyboard used for logging on, and at least a few people used that character in their password. There, none of these workarounds were available – and so those people were now completely locked out of their iPhones.

The Register reported on this on April 12, and a few days later suggested that Apple was working on a fix. I won’t keep you in suspense; I just verified that the fix landed with the recent May 11 update.

This is, in an of itself, not a fascinating story, but with interesting things to talk about at its periphery.

First of all, The Register never showed a single screenshot. This led to a lot of confusion and speculation in the comments. Turns out, screenshots are valuable not just with bug reporting, but also with bug reporting.

Second, check out this Czech keyboard. Even within the limitations of the ancient QWERTY, there’s a lot of cool stuff happening here. Two new accented keys just appear on the top layer when you switch to Czech. Both have magical properties, too. They’re the modern “dead keys” that either stand alone, or get combined with the previous letter if that makes sense.

This is the stuff typewriters, and even desktop keyboards, could only dream of. But, as always, more software means more bugs, including some with unforeseen consequences; a typewriter could never break this way.

Thirdly, there is this interesting tension between us being led to believe “more interesting passwords are safer,” but then sometimes being penalized for actually making them interesting. A decade ago someone used emoji in their password without realizing they won’t be able to input it, and I’m sure there were other examples.

But the most interesting, to me, part? It’s the diacritic itself. Under one of the posts, a commenter wrote:

Stick with the 7-bit ASCII subset. You will never go wrong.

7-bit ASCII basically means “26 Western letters and nothing else.”

I hate this. I know it’s objectively true – in the late 1980s I felt a sense of relief my name didn’t have any of Polish language’s nine diacritics, which would complicate my life. Even just yesterday in Germany, I spotted this:

Software still struggles beyond ASCII. But this is why we need to keep pushing. Diacritical characters are to be found everywhere in the world. They’re detailed, and varied, and filled with histories. Umlaut is not diaeresis. Kreska is not the acute. A háček is not a breve. They’re rarely optional decoration, and often not even decoration at all; learning about Turkish dotless i might completely upend your understanding of what’s an accent and what is not.

If you don’t have a favourite diacritic, you are missing out. Even the names – grave! ogonek! horn! – are beautiful. (Háček is also known as caron and a wedge depending on context, and in other regions referred to with beautiful words kvačica and strešica.)

If you’re interested, here is David J. Ross’s 22-minute talk about getting to love diacritics from the perspective of a type designer. It’s filled with craft and playfulness:

My favourite accent is, obviously, ogonek. Just looking at Adam Twardoch’s guide on how it should be drawn fills my heart with joy:

Mailbag: Photoshop’s focus post

The post about Photoshop’s new dialogs traveled through some of the internet’s pipes and alleyways. Michael Tsai has a nice roundup of reactions; let me pick a few things that caught my attention.

1.

Nick Heer at Pixel Envy made a discovery that Photoshop’s new windows are… websites:

Maybe it really is possible to build a web app that feels platform native. But I have never used one — not once — and for this mess to be increasingly used in the industry-standard professional suite of creative tools is maddening.

I think it is possible – especially in the realm of classic form fields – but you really have to care and step up and test and replicate a some stuff that the operating system controls give you for free. (As an example, if the web platform/​Electron don’t give you access to the “keyboard navigation” OS accessibility setting, you’ll need to build a bridge from the OS to pass it through. This is how Figma’s Electron app got haptics, for example.)

It is true that we don’t see that level of effort often. But there are also bad native interfaces, and there might be more; Roger Wong recently made an interesting observation that stuck with me. Emphasis mine:

The mechanism differs but the outcome is the same: the platform stops being a place a designer can rely on. […] [Text user interfaces] are back because the platforms quit, and the curriculum can’t fix that.

I think I agree with this; I’ve felt there haven’t been a lot of improvements in native desktop interfaces recently.

In the mid-1990s, Apple was losing to Windows 95/98, and after years of falling by the wayside, the team eventually got their priorities in order, and rebooted classic Mac OS into a (I believe generally successful) Aqua. And in later years, Apple as a whole has often been good about creating extra distance from the peloton even if there was no immediate danger of being overtaken.

But not here. Windows lost its way, and perhaps even the memories of the darkness of the 1990s and the revival of the 2000s are now forgotten. Even if Liquid Glass was executed extremely well, macOS would still feel bereft of true evolution and care. I know there have been some slight improvements to window tiling and more recently Spotlight, but little of this betrays urgency or suggests a vision.

Finder feels like it’s been abandoned for over a decade. AirDrop UI is worse in use than many of the file sharing interfaces that came before it. This common UI is stuck in the state of the art of display colour science that is out of the previous century:

Just on the topic that is fresh on my mind: Why does Shortcuts feel like a toy in all the moments it shouldn’t, but few of the moments it should? Why does the keyboard customization situation feels so messy? Or, why are both macOS and iPadOS still stuck in the ancient way of thinking that menu bars contain all the app’s commands, when the modern approach is: it’s command bars that do, with menus containing only a subset? An innovative modern operating system would offer a universal API for command bars that any app that wants one could use – instead, apps invent their own with varying levels of success and UI quality, and automation tools cannot do much since nothing’s compatible. (This in particular is an example of an area where web apps started leading the way.)

These are just some examples that come to mind. It’s true I have admired and been inspired by some work done on Apple TV and the Vision Pro, but we also have to acknowledge that designing for net-new platforms is in many ways easier than for legacy ones.

2.

Back to Photoshop. In the Hacker News thread, at least one person from Adobe dropped in to comment, and one paragraph caught my attention:

These changes were part of the Beta program. As far as I am aware the response there was not on the same level as this blog post.

It’s not my intention to pick on this Adobe employee, and I am not aware of the specific of their beta program (although I have used Photoshop in beta for a few years). But from my experience, this is why beta testing fails in this regard:

  • People in beta programs might be more lenient and excited to experiment.
  • For obviously broken small UI things, people will be more inclined to think “oh, they will surely take care of that in the polish phase.”
  • In general, reports of smaller UI things are less likely than bigger functional bugs like “this is not working” or “this is really slow now.” You really have to encourage and reward and incentivize people to do that, and usually identify the right people first, too.
  • Please excuse my directness, but Photoshop’s user interface has felt low-quality for at least a decade now. There are a lot more examples. It’s hard to expect people in the beta to flag small UI stuff – including literal broken windows – when the evidence all around them is that the company doesn’t care.
  • Just because we all encounter interfaces doesn’t mean everyone knows how to identify the things and say the words and connect the dots, especially when it comes to generally undefinable and unmeasurable craft. Good UI is deep expertise. Just like you cannot research or data science your way out of fundamentally bad product decision-making process, you also cannot add craft through relying on your users to tell you. You need to foster this on the inside.
3.

Oh, and when I say “broken windows,” I’m not just being cute. Here’s an example of Photoshop’s “explore” halo that occasionally appears on top of another app just because I have Photoshop open underneath. And, there is nothing I can do in Photoshop to get rid of it:

I think there is something fundamentally very broken with Photoshop’s (custom?) window management, seeing how PS windows jump in front of other applications, or how PS breaks other apps’s mouse pointers. But that’s a story for a different post.

“There seems to be a file that is just filled with undecipherable Morse.”

On April Fools in 2021, the popular xkcd comic ran Checkbox, which was a Morse code puzzle in disguise. (It’s interesting to see the community trying to figure out what it actually does.)

Engineer Max Goodhart built the front-end and wrote a summary of the whole project:

This year was a doozy. We specced and scrapped several different ideas in the months leading up to today. We finally settled on today’s concept just 3 days ago. The need to do something simple was a really useful constraint, and we leaned into the idea of making something primitive but deep.

The team seems to have had a lot of fun with it, including even JavaScript being encoded in Morse Code (the link in the blog post no longer works, but you can still see it on the Internet Archive).

Goodhart also wrote about the immense challenge of adjusting the Morse tapping speed to the user, which counterintuitively ended up needing… adjusting the user to the speed. But the best part is that the server communications used the Morse code in URLs, as well:

We took great pains to make the API for this project use morse code in the transport. If you take a look at the network inspector, you’ll notice that the URLs requested have morse code in them.

This worked for every combination of letters imaginable, with two oddly specific exceptions: a solitary E, and a solitary I.

I liked this description of what transpired next, which would have made me think I was going insane, too:

Then, an even stranger thing happened. I copied and pasted the correct URL into my browser and pressed Enter, and right before my eyes, it deleted the ”.” from the end of the URL and returned a different result.

I was delighted to discover an answer here, not only because in retrospect it’s such an obvious thing that was staring us all in the face for decades, but also because it has interesting URL construction consequences.

“Traditionally, fonts were just shapes.”

Should you ever be worried that displaying just one glyph could take almost 2 seconds and slow down your website by as much? Naw, of course not. This wasn’t a problem already in the 1980s and, in the lord’s year 2026, computers are pretty good at rendering a letter or a symbol at a moment’s notice.

Ha. I was just messing with you. Of course you should always be worried about fonts. All the time. Typography is beautiful, but fonts are brutal. They will constantly put you to the test, they will find ways to get out of alignment faster than a Zastava Yugo, and they will teach you about corner cases in places you didn’t even realize had edges.

Fonts will break your heart like it’s the month before the prom again, and again, and again.

Or, in Allen Pike’s case, break a heart somewhat literally. Pike wrote a nice quick story of the complexity of what needed to happen to show the heart emoji, and how under a very specific set of conditions – a certain browser, a certain emoji font, a certain emoji within that font – this led to an extreme slowdown.

What’s really interesting is that in order to fix it, Apple can either improve Safari or the font itself, and at the moment of writing, it wasn’t clear what was the right thing to do. (Oh, yeah. Fonts don’t just have bugs. Fonts have many kinds of bugs.)

Another interesting in-between-the-lines thing is that Apple’s emoji are perhaps the only survivor of the original skeuomorphic pre-iOS 7 era. Even today’s emoji party like 2008 never ended – still glossy, still textured, still bitmapped. I’m curious whether somewhere deep inside Apple, there exist exploratory designs for flat, vector versions of emoji that never saw the light of day.

“Have you ever been annoyed by your Mac’s media keys?”

In our Unsung yellow pages, in between people writing Chrome plugins to fix UI of other apps, and gamers creating mods to fix bugs that the developers leave behind, we need to make some room for another category of apps.

Some time ago, Daniel Kennett created a little utility called Keyhole with a singular purpose:

Have you ever been annoyed by your Mac’s media keys triggering a random video in your web browser, doing something else weird, or by them doing… nothing? Even though your music player is right there?

Me too! And so Keyhole was born.

Keyhole intercepts media transport key presses before the operating system gets a hold of them, and promises to do a better job dispatching them to the right place.

This week Kennett added another feature – the app will monitor the repeat setting that apparently occasionally gets out of whack, and fix it for the user.

We could call these kinds of apps “janitor apps.” I know of a concept called cron jobs, but I’m assuming these quiet workers do backend-y things like moving files around, cleaning up databases, pinging servers, and so on. I am less aware of work like Kennett’s that fixes stuff on the UI layer.

Is it strange that I find this kind of an app pretty… noble? Of course, Apple should fix it; perhaps Bugs Apple Loves could even introduce a serious multiplier for “a bug bothers someone so much they fix it for Apple.”

Of note in the last dialog box: “Keyhole has fixed Music’s repeat setting X times.” I think this kind of a counter is pretty brilliant.

“Examining the changelog in its entirety would be a massive task, given that it was now over 200,000 words long.”

I had some idea that many popular games have mods to tweak them – from small appearance tweaks and fan-made translations, to bigger gameplay or UI changes (and even an occasional trojan horse).

What I didn’t know was that for some games there is a whole community of modders who do one thing and one thing only: they fix bugs that the developer didn’t bother fixing.

This 1.5-hour (sic!) video by Fredrik Knudsen talks about a story of such a community for a popular game Elder Scrolls V: Skyrim:

I won’t lie: this video was a bit of a frustrating watch. The presentation is dry and takes its time. I was annoyed at Bethesda for not fixing the bugs to begin with and creating the whole mess. Also, some of the people in this story do not appear very mature, and post-Gamergate I have little patience for that kind of behaviour.

On the other hand, this covers so, so many interesting things and provoked so many thoughts:

  • how hard it is to agree what a bug even is,
  • how a bug fix can introduce more bugs and be an overall net negative,
  • how a new distribution method for something can drastically change its nature,
  • that everything, as always, boils down to communication,
  • that in community- and volunteer-led projects, not spending time on governance will come back and bite you.

Not to mention these topics:

  • dependencies
  • change management
  • centralization vs. federation
  • copyright and DMCA
  • version control
  • volunteer burnout
  • issues of trust and ego and power

If you are responsible for bug-fixing processes at a company or with a community, I am curious if you find this video valuable. I did.

The funniest moment was that drama/​debacle about a certain in-game portal was nicknamed… Gategate.

Not to mention the ending is truly poetic, and not something I expected.

“That’s how floating point errors and triangle numbers solved a mystery.”

Minecraft is so complex that it’s sometimes hard to know what is a bug and what is not.

Here’s the logic of the game:

  • If you fall from height, you receive fall damage.
  • If you fall from height but you’re in a boat, there’s no fall damage.
  • If you fall from height and you’re in a boat, but you fall from a distance of 12, 13, 49, 51, 111, 114, 198, 202, 310 or 315 blocks, there is fall damage and you die.

The first is common in games.

The second is – I believe! – a former bug that was grandfathered in as a design decision: people got used to it, started relying on it, and it became “too big to fix.” The retroactive explanation became that the boat is your shield and takes all the fall damage, which is a very Hollywood action movie way of looking at the world.

So, only the third one is a bug… obviously.

But why those specific numbers? Here’s a 16-minute video by Matt Parker at Stand-up Maths that tries to answer it:

It’s an interesting video because it’s lighter on bug causes discussion, but heavier on math – and the moment you realize those numbers above are not random at all and coalesce into a nice formula, is genuinely a pretty fun moment.

I thought this was interesting, and a little contribution to a larger debate about how hard it is to even agree what a bug really is (which I previously briefly talked about).

“Rather than trying to fix this mistake, the developers leaned into it hard in the sequel.”

A fun 16-minute video from outsidexbox with 7 examples of videogame bugs where the game creators not only owned up to their mistakes, but creatively acknowledged or remixed those bugs in subsequent versions:

I didn’t know about most of these, so I did some googling and created a list for reference:

Off the top of my head, I cannot think of any non-videogame software that received a similar “bugs as lore” treatment from people responsible for the bug in the first place.

Microsoft made a blue-screen-of-death screensaver, but it was originally third-party, and kind of a prank? A mean-spirited one? I didn’t find this particularly good.

The likely second-most-famous error message, the fail whale, transcended Twitter and was even referenced in other products…

…but as far as I understand Twitter the company was itself embarrassed by it, and eventually switched the whale to a caterpillar.

(Those two examples aren’t really even bugs in the same category as those in the video, anyway.)

“Approximately 21 times the estimated age of the universe”

A few years ago, some sort of a bug at my work caused all of the timestamps appear as “54 years ago,” a seemingly arbitrary date. It took me a bit to realize: “Wait, you know what year was 54 years ago? 1970!” “Why is 1970 important?” asked another designer. I explained that by convention, Linux time counts up from Jan 1, 1970 – and so if the time “value” is zero or unavailable, as it was because of the bug, it would be rendered not as an error, but as that specific day long ago.

Computing is filled with all sorts of arbitrary numbers like these. The most famous one was Y2K (99 + 1 = 00 if you only allocate two digits), Pac-Man’s kill screen was number 256, people still bring up the infamous and likely non-existent “640 kilobytes should be enough for everybody” quote, and the Deep Impact space probe died a lonely and undignified death after its timers overflowed the two pairs of bytes given to them.

Here’s a new magic number to remember: macOS Tahoe has, for a while at least, a kill screen of its own – after 49 days, 17 hours, 2 minutes, and 47 seconds (or, 4,294,967,295 milliseconds), one of its time counters overflows and no new network connections can be made, rendering the machine rather useless. The only solution is a reboot. Talk about a deadline!

(Well, new-ish. In perhaps a bit of karmic payback, Windows 95 and 98 once had a similar problem with the exact same threshold of 49.7 days.)

Wikipedia has a nice list of other time storage bugs. The next big one? The problem of the year 2038. The technical fix, as always, is to give the numbers a bit more room to breathe. This is, in a way, kicking the can down the road, but that might be okay since the road is rather long:

Modern systems and software updates address this problem by using signed 64-bit integers, which will take 292 billion years to overflow—approximately 21 times the estimated age of the universe.

However, as always, the technical side won’t be the hard part.

“Prototyping turned into an excuse for not thinking”

The 2016 launch of No Man’s Sky and the 2020 launch of Cyberpunk 2077 were catastrophes. No Man’s Sky fell so incredibly short of the promises the founder shared over the years – from smaller ones like rivers on the surface of planets, to huge ones like seeing other players – that some people felt it must have been a scam all along.

The other game was a simpler case study: Cyberpunk was buggy as hell. Not just the abysmal performance, but also the overall quality. People called it “the Hindenburg of videogames” and made YouTube compilations and listicles of its often hilarious bugs: cars exploding for no reason with perfect comedic timing, intimate body parts protruding through the clothes, and the infamous T poses.

In an unprecedented move, Microsoft slapped a big warning atop Cyberpunk’s app store listing, and Sony pulled it from their store altogether.

But it is 2026 now, and both games redeemed themselves. For years after the launch, the No Man’s Sky team worked hard on adding promised features:

Over a decade on from its initial reveal, No Man’s Sky both manages to remain the same game it was at launch while also bringing almost every single missing feature (and dozens of new surprise ones) into the title – implementing them intelligently and with great consideration for how it will affect the core of the game. They achieved their redemption years ago, yet continue diligently with massive update after massive update.

No other title has done what Hello Games have managed to achieve. And the best part? Every single update, patch and addition to the game was and is 100% free, with no falsified hype or build-up to each update.

Cyberpunk 2077 had a redemptive arc of its own, too, highlighted and contextualized in this 17-minute video from gameranx. Today, both games are rated “very positive” on Steam, and are actually still gaining daily players.

So, wonderful comeback stories, right? Depends on how you look at it. It’s great that both these games ended up being good products, but perhaps not as great that it was all happening in the open.

The videogame industry tried to get creative about it and established an idea of “early access”: being able to purchase an incomplete game earlier, and watch it get better while the publisher receives funding to keep going. But for every Minecraft there is Godus, and for every Kerbal Space Program there is The Day Before. Plus, neither No Man’s Sky nor Cyberpunk launched in early access with attendant caveats and discounts. (By the way, Wikipedia’s entry for early access is worth checking out – it’s so eloquent I’m surprised not to see any warning boxes.)

There seems to be ongoing and perhaps rising frustration with companies releasing software products too early and fixing them in flight, if at all. Already in 1996, Geoff Duncan wrote about his annoyances with that:

What Beta Means Now: […] In many cases – particularly with Mac Internet software – “beta” doesn’t mean anything close to what it used to. We’ve seen programs in public beta that not only contain innumerable known bugs the developers are aware of and plan to fix, but also accumulate major new features through subsequent releases. Similarly, we’ve seen products that change fundamental system and technology requirements during beta – details which should have been etched in stone long before. Beta often means what “alpha” or even “development build” used to mean.

Subsequently, Google and other web-first companies diluted the meaning of beta labels even more.

The trend of premature launches extended to devices, too. About two years ago, AI assistant gizmos from Humane and Rabbit were pilloried by audiences for launching in an effectively unfinished form. Both devices failed in the market; MKBHD’s video reviews of Humane AI Pin and Rabbit R1 remain both entertaining and informative watches.

AI complicates this even further in many ways. I enjoyed Pavel Samsonov’s recent post on his blog Product Picnic analyzing another disastrous launch: Grammarly’s writing advice feature that replicated well-known authors who never agreed for their likenesses to be used this way:

Reading between the lines, Mehotra’s interview paints a picture that I think many tech workers will find familiar: features are conceived, coded, and shipped as quickly as possible. He is happy to admit that the feature was a mistake… in retrospect. But in the moment it actually mattered, critical thinking was swept away by the false urgency of pushing things out.

It is worth reading in full and following the links, too; I watched the mentioned (tense) interview, and was similarly frustrated with the CEO’s lack of accountability or even a hint of an explanation of why the feature was launched to begin with. Key line from Samsonov’s post:

If you don’t know what are you trying to learn when you ship a prototype, do not ship a prototype.

This becomes even more important as the difference between a prototype and a final product is now thinner than a retina pixel. Both No Man’s Sky and Cyberpunk had, at least, well thought through foundations.

I understand that for some people gen AI software building tools is a discovery – perhaps for the first time – of a genuine joy of creation. But there’s also the other, newish side, a sort of “cult of velocity” where people show screens filled with agents coding things as if the world needed every possible app right this second.

Velocity and urgency can be important, but it’s hard to be careful and thoughtful when you’re going really fast; unsurprisingly, some don’t know what to do with that newfound AI-powered speed or realize the importance of thinking about crucial aspects other than time to market. (When digital cameras came around, the barrier to entry for photography was drastically lowered – it was possible to take a lot of photos without worrying about cost or quality. Tons of people took tons of objectively subpar photos; some were the end goal, some were a stepping stone toward more photographic mastery. However, I am not sure I remember people on either side ever bragging “I took over 1,200 photos today!”)

All this could be contrasted with movement of slow software (the name is part of a bigger slow movement although has unfortunate connotations in tech – it’s slow as in “speech,” not slow as in “beer”). Jared White in 2023 defined it as:

  • Sustainable software. Architecting and writing code in ways which are easily understandable and maintainable over time, requiring few dependencies and a rate of change that is healthy for the underlying ecosystem.
  • Thoughtful software. Working through feature development and making decisions based on what will benefit the userbase over the long term, placing mental and social health as priority over immediate gains or selfish interests.
  • Careful software. Seeking to understand the ways software might be used for harm, or itself be harmful by taking attention away from more important concerns in the broader culture.
  • Humanist software. Recognizing that most software—at least in application development—is primarily written for humans to understand and reason about with ease across a wide array of skill levels, and that relying on complex code generators or “generative AI” tooling to resolve complexity instead of simply building simpler human-scale tools is an industry dead-end.
  • Open software. Looking to established collaborative software movements like open source and the standards bodies responsible for open protocols to inspire how we build and maintain software (regardless of licensing).

I don’t really have a conclusion for this meandering post, as I am not sure a snappy conclusion is possible. Perhaps some of the links above can provide inspiration or food for thought about urgency, reputation, and doing things in the open.

Some patterns I’m noticing are:

  • Velocity is never an end goal.
  • Velocity is only one of many ingredients of software building.
  • It is necessary to think of people who will experience your work-in-progress as it is, not as it might one day be.

Linear’s clever internal redesign UI

I was impressed with this clever internal interface at Linear, shown inside this larger blog post:

The dev toolbar exists directly inside the app and allows us to easily toggle feature flags on and off. When something didn’t look right in the refreshed UI, it took us just one click to compare it with the previous version. That made it easier to determine whether the refresh had broken something or whether it had behaved that way before. Having the updates live behind feature flags also meant that instead of developing the redesign in isolation and shipping all the changes at once, we could integrate incremental changes to the platform.

I also cut it out here so it’s easier to see:

Here’s what I like about it:

  • It’s a separate UI surface: Rather than being awkwardly integrated alongside production UI and adding jank to it, it is a clearly delineated toolbar you know users won’t ever see, allowing the rest of the interface to always feel like production.
  • The feature flag toggling is easy: You don’t have to go anywhere else and possibly log in to toggle a flag, and you don’t have to wait for it to take effect. This will mean more people than just the core team members will be using it.
  • Toggling this particular feature flag is as easy as clicking on a tile: I don’t know if anyone can promote others flags their care about to be easily toggle’able tiles, but I can imagine this really beneficial, too.
  • The feature flag toggling is instantaneous without any visual jank: I understand that the best way to compare two things visually is to switch between them promptly in situ; our visual system is really good at spotting even small changes when aided this way.

Each one of the above bullet points is individually a small point of friction and easy to renege on, especially when it comes to internal-only interfaces. However, a combination of all of them results in great compounded interest, and I bet makes this interface effective – in addition to just feeling like fun to use.

Appreciate Linear sharing this internal detail; if you are using an interesting internal tool or UI that you are allowed to share, please consider it and let me know!

“Durial321 is a banned RuneScape player and a bug abuser.”

RuneScape is a popular MMORPG that reached its peak popularity in the late 2000s.

In the game, combat – colloquially known as PvP, or player vs. player – is limited to a specific map area (called the Wilderness) and otherwise people’s houses.

On 6/6/6 (sic!) a bug in RuneScape made it possible for a few players to start killing others outside of designated areas, without them being able to defend themselves. One of these players, Durial321, gained a lot of notoriety:

A player called Cursed You had invited some friends to his in-game house once he had maxed his construction skill, but decided to eject them all from the premises. Things turned sour, however, as a group of players marked as PvP in the house didn’t lose this PvP flag when ejected, allowing them to storm through Falador and massacre whoever they pleased. The most notorious of these players was named Durial321.

This event went down in internet infamy and meant that many players lost their items when killed as well as the banning of those involved.

I don’t have any context of RuneScape and I found it really funny to learn about this event from different retellings of the story.

This wiki entry reads almost as journalism:

Several others were able to use this glitch, but Durial321 abused it the most. His rampage lasted for about an hour, starting at Rimmington, where the house party was, then proceeding to Falador and subsequently Edgeville. At Edgeville, he gave Voodoolegion the green partyhat, who never gave it back to him. Soon after, he finally encountered a Jagex Moderator, Mod Murdoch, who disconnected him and locked his account. Durial321 was later permanently banned from RuneScape. In a 2006 interview, he said that player killing outside of the Wilderness was exciting, although he felt bad for the players who lost their belongings.

The 2006 incident later became known as the Falador Massacre.

(The tone is even more funny if you actually read the interview.)

There is also this more modern retelling that feels like scary story time by the campfire:

Reactions from players were initially kind of incredulous. Plenty of people were shocked and found the whole incident quite funny. Durial had essentially broken the game, after all. Some players wanted to be like him, whipping strangers to death and taking their items. But soon, as more players started hearing about what had happened and seeing the video, the mood shifted. Players wanted Durial321 hung, drawn and quartered, with his head displayed on a pike outside Lumbridge Castle.

You can witness the event PC Gamer called “one of the best all-time MMO bugs” by yourself since there is video capture of the Falador Massacre taken by one of the witnesses. At least to me, it’s rather incomprehensible.

Fear not, however, because there are many (!) documentaries. This recent one is reportedly the best one and also goes into the technical details:

Without spoiling too much, the bug was a classic Swiss cheese situation involving a new untested item, a race condition, peculiar timing, and a player with an unusually high uptime and a whole lotta luck.

“Please star to express your interest.”

An interesting crowdsourcing effort from Mimestream that asks users who want snoozing to pick up a phone and dial their representative put pressure on Gmail to add that feature to the API.

I wonder how much of a chance of succeeding this has. The issue has been open since 2018, and was reopened in 2023. It has over 5,100 stars. Those dates seem old and the numbers seem huge, but I don’t have a full frame of reference. Casual search shows there are only two more bugs that have been starred by more people.

Sins of our Finders, pt. 5

I feel macOS these days starts feeling like Windows in the 1990s where occasionally some core component of it breaks, and a reboot is necessary to restore it to full functionality again.

But even with that in mind: this happened literally right after the reboot, with nothing much happening and no other signs of the system in distress.

It’s hard for me to even understand what would make this kind of thing pop up. Trash feels like one of the core tenets of a GUI – like undo, or copy/​paste, or windows gaining focus. You don’t expect it to just… stop working, especially with a circular error message like the above.

I’m with stupid →

I think a lot about bugs or design decisions that make software appear dumb.

At some point in my career I started fitting everything against two principles: “don’t make your app treat your user as if they’re dumb” and “don’t make your app itself feel dumb.”

To wit:

This is, very obviously, my website. I have made it from scratch. I have visited it a million times. And yet, at some point my friend Noah shared a link of it with me, so now Safari occasionally announces that with glee when I check it out.

Me having visited something many times should outweigh someone sharing it with me once.

There is a close box here, although you have to hover over the bar to see it. (And, after closing, it seems to come back after a few days!) I can also right click and choose Remove which does… absolutely nothing.

I believe this whole feature is called Shared With You. Elsewhere, on occasion, I find it useful. But its tentacle right here makes Safari appear just… kinda obtuse.

Also, speaking of obtuse: Can you spot a grave typographical mistake I made on this screenshot? (I already fixed it in production.)

“Problem solved, right? Well, not exactly.”

I was embarrassed for Apple when I saw the recent bug fix for columns introduce a new bug, explained in this post by Jeff Johnson:

Without the path bar, the columns are now taller, but the vertical scrollers remain the same height as before, leaving vertical gaps, a ridiculous amount of space between the bottom of the scrollers and the bottom of the columns, looking silly and amateurish.

It’s impossible to talk about craft without talking about embarrassment, and pride, and shame, and lust, and a lot of other words – all tricky to describe, all fluffy. So, I tried to interrogate my feelings.

First, it was embarrassing that it broke. I’ve been there: you build a complex system, and forget about some lesser-known state. That’s why it’s important to invest in whatever it takes to shine a light on those states: quality assurance, automatic screenshotting, tests, and so on. Sometimes it’s simple hacks – like half of your team having scrollbars visible. And when you notice a bug, you try not to just fix it, but to rebuild it to be stronger (“leave the campsite in a better place you found it”) – be it by fixing the cause and not just the symptom, adding unit tests, changing practices, and so on.

But it also felt embarrassing how it broke. It feels clear there’s some manual calculation going on somewhere, and someone forgot to add this new change to it. One of the tricks I learned over time is that a well-designed system designs itself, but it takes effort and imagination to make a system resilient in this way. Here, if there was some abstraction of “adding stuff to the bottom,” then you wouldn’t have to worry about adding extra math. The system would take care of itself in many of these corner cases you will forget about.

I don’t want to shame (see, that word again!) individual people at Apple because I don’t know if it’s the lack of talent, or the whole system being wired in a way that doesn’t reward forward thinking or the kind of invisible work that needs to happen in those spaces. But the embarrassment should be there – if it doesn’t exist inside Apple, then that’s perhaps the sign of a real problem.

How to make sure a designer never files a bug again

  • The UI for filing bugs is inscrutable and has too many hoops to jump through.
  • No one does anything unless every field has been filed meticulously and there is a clear repro.
  • The designer is ridiculed if the thing isn’t actually a bug, is a duplicate, or if it was filed in the wrong place.
  • Front-end bugs are automatically “minor” or “nice to have”s without listening (as there is no loss of functionality, and no data loss).
  • The designer is always responsible for stating how it should work, without being able to say “I am not sure why, but this started feeling off and it’s in an important place. Can we investigate?”
  • “This is as designed” is an automatic conversation ender.
  • The tiniest of external reports, social posts, or blog posts, immediately are prioritized higher than in-house experience.
  • Once every few years, a designer gets 20+ demotivating automated emails saying 20+ bugs they filed over the years have been closed automatically during a purge, without any word of explanation.
  • Simple human touches like “thanks for filing!” or “nice catch!” never enter the picture.
  • Engineers never file design bugs themselves.

If you’re an engineer, I can sense you might be getting frustrated, as most bullet points I listed look like extra work. I agree with you. It is. This post is as much about process, as it is about culture and the incentives it establishes. The best places I’ve worked were filled with shared trust and treated bugs as a joined responsibility of everyone, rather than a black-and-white division into “filers“ and “fixers,” with the ultimate end goal always being user’s experience – nothing else.

I also understand this dives right into an age-old tension between manufacture and craft. Bug-fixing processes have to be well-oiled bureaucracies with very specific rules so that they don’t turn into a pile of vibes and Brownian motions. But design (and, by extension, a lot of front-end) doesn’t work like that. Design needs room for taste, for careful exceptions, for escalation of immesurable things, and for a certain flexibility in even the basic definitions.

If it’s a tiny, but embarrassing bug, or a flow killer, or a thing that bothers your most valuable group of users, or something appearing in a well-trafficked place – it is no longer tiny. If it’s working as intended, but it feels buggy to the user – it ought to be a bug. If it’s a long-standing bug, it should be considered as cumulative damage already done, not “oh, this has been like this for a long time, no one cares.” If there’s a shaky repro, but the bug feels important, you need to work from principles or analyze the code. If it’s something no one mentioned externally (ergo: why fix it?), consider a lot of bugs rankle but never get reported, particularly if your company doesn’t project an external presence of caring about feedback and acting upon it. cough cough Apple cough cough cough cough cough dies coughing

Of course, designers have responsibilities in the process also, among them mutual respect and understanding of engineering, clarity of communication (particularly about things that are hard to reason about mathematically), seeing patterns that could be grouped into bigger bug bundles to make fixing more efficient, (occasionally!) helping figure out a fix if the obvious fix isn’t available, and shared understanding with their team about what actually matters. There is always a thousand details that could be better, but for every thousand only a hundred might actually be worthwhile. Flooding the bug process with irrelevant minutiae that won’t realistically ever be fixed is not very helpful.

This is the only way I know of to capture the full spectrum of bugs that ruin software – from front-end to back-end, from visual/​interactive quality to works-or-not functionality, from what can be measured to what never will be. And this is not just about designers, of course. It’s not even about any non-engineering function. Design serves everyone; if your bug-filing UI or your process or your definitions are not well-designed or -balanced, I strongly believe you’re also hurting engineers on your team. And you’re definitely hurting your users.

“Users were gleefully told to reload the game.”

This 9-minute video from the fun game show Lateral (with Tom Scott!) covers a particularly interesting bug in the 1984 game Karateka:

If you don’t want to watch the video and try to figure it out alongside contestants, you can read more about it here, and also see it in action.

Karateka was made by Jordan Mechner and I bet his name will come up again.

“State-sanctioned monster executions over a server hiccup”

This is a really funny story happening in the online universe of Final Fantasy 11:

Once killed, a notorious monster shouldn’t respawn until after the next monthly tally, but lately defeated notorious monsters in Limbus have been reappearing early. That’s because, Square Enix said, “the server-side data recording the defeat status of notorious monsters is unexpectedly being cleared.”

Thus, there’s only one way to guarantee no players are robbed of hard-earned Limbus loot: Square Enix is dispatching Game Masters to personally murder every notorious monster in Limbus so the FF11 servers can properly verify that they’re really, truly dead.

“To achieve this, Game Masters will visit each World in sequence and defeat each motorious monster individually,” Square Enix said. “We apologize for the inconvenience.”

I know this is not a bug fix per se, but it’s interesting to be doing some bug cleanup from the inside.

“An integer overflow causes an enemy to spawn directly on top of the player”

A nice counterpart to my post from a few days ago – a 5-minute video by philive of more kill screens from various classic arcade games, with simple explanations.

“The autocorrect battle of wills”

I liked the angry website Bugs Apple Loves because it’s hitting on something that got me worried in recent months: Apple has been bad at bugs for a while now, but we might be overfocusing on giving them crap solely for some of the most visible – even visual – Tahoe stuff.

This is a condensed list at the time of writing, as the site itself doesn’t make it easy to see it:

  • Mail search doesn’t work
  • Autocorrect won’t take no for an answer
  • Apple Pay: card icon changes address
  • Google Contacts sync is a black hole
  • AirDrop: Looking for devices...
  • iCloud Photos: ‘Uploading X Items’
  • Spotlight: ‘Indexing...’
  • Personal hotspot won’t auto-connect
  • Apple Watch widgets won’t let go
  • iOS text selection is pure chaos
  • AirDrop shuffles targets mid-tap
  • macOS 26 window resizing doesn’t work

There are themes here: “the interface doesn’t remember my preference,” and “things move around as I interact with them,” and “some process gets clogged up,” and “a thing gets stuck and doesn’t respond to interface actions.”

What I appreciate about this is that none of this is very “visible” stuff, but the insidious things that add up and bother on the daily basis, chipping away at your flow first and sanity second – which the site tries to quantify via a formula:

I think this is really interesting, even as a satire.

I found it’s really hard, if not impossible, to justify design or experience bugs using the same frameworks as other engineering bugs. As Mike Swanson wrote: “You cannot easily measure the resentment. Or the rage clicks when they smash a button to dismiss another […] pop-up.”

A lot of it is utterly subjective. Various small frustrations add up in non-linear ways. A lot of it doesn’t subscribe to binary “data loss or not” or “does it function or not” classifications. A lot of it feels heavy to fix in terms of context switching, so it’s timeboxed and then discarded when the time box overflows.

I have seen engineers say “Oh, it’s a long-standing bug, it’s been like this for 3 months” as a justification to deprioritize something, while to me it feels like that should be an accelerant. The users have already been suffering for 3 months!

So maybe metrics like these could actually help? Quantifying at least the blast radius (affected users + usage per day) seems valuable, not to mention the embarrassment of seeing something like “9.1 years unfixed by Apple.” (And yes, internal embarrassment and shame should also be a metric.)

This would be harder to do for creators of the site, but easier inside Apple: I would also try to quantify vocal user frustration. One of my tricks when thinking about bugs has been “Notice when your users are really angry about invisible stuff.”

…for example someone going on and on about Finder.

Sins of our Finders, pt. 4: Eject

If you plug in a CD drive (he said with a straight face in the lord’s year 2026), and then eject too soon, the system offers this dialog, which allows you to say: Eject whenever you’re done with whatever you have to do.

But more modern media, like SSD drives, don’t show that window. The best case scenario is that you get a dialog box like the 1990s never ended:

It gets worse. Often, you get zero help in identifying what the “programs” actually are. (The word on the street is that it might be stuff like Spotlight indexing, which you can’t really control.)

More often than not I just click Force Eject or jank the drive cable out, which feels really unpleasant. I would guess many people do the same.

So at this point we are two steps worse than the original CD experience, which… wasn’t even that great! A pretty clear improvement on this already exists elsewhere in macOS, and could be reused here – “hey, you don’t have to do anything, just give me a second while I finish up here.”

(Can’t help but notice the discrepancy of visual styles of these windows, and even the inconsistency between calling things “applications” vs. “programs.”)

Reported to Apple as FB21787458.

“Stuck on level 256 forever”

I’d guess a lot of people know that the original 1980 Pac-Man ends accidentally with an iconic, glitchy, and impassable “kill screen.” Many people will also nod with recognition at hearing the kill screen is level 256, a number that immediately gives some ideas on what might have happened.

But this fun 11-minute video from 2017 by Retro Game Mechanics Explained doesn’t stop there. It shows, step by step, exactly what is going on when you reach level 256, and how each one of the glitchy things appear on the screen.

It’s a little mesmerizing, like watching a building demolition in slow motion.

“I’m a shame-driven developer.”

Found listening to this 2-hour episode of The Talk Show podcast with Daniel Jalkut very enjoyable, and more thoughtful than just “bitching about Tahoe.”

One particular thing that stood out to me was a discussion of shame and embarrassment and pride that all come with shipping software. And looking to Apple itself for direction that the company is not really providing, as many of their apps are not using the new Liquid Glass interface – or when they do, they use it in ways that are inconsistent or disappointing.

Some other good themes:

  • it’s okay not to change something if the alternative is change for the sake of change, a posture Apple’s hardware team feels more comfortable with than Apple’s software team
  • internal Apple politics and the story of the Control Strip
  • loved this phrase from Gruber about the macOS’s Tahoe release: “they vandalized it.”

Also, this:

A fair criticism of Apple over the years is that sometimes fixing 50 little misaligned text boxes or divider bars… using your time to do that, is time better spent than adding another user feature.

“Every Mac’s floppy disk had a garbage name”

Fun little story by Bruce Horn on folklore.org about the original Mac and how modes are sometimes good:

We went to quite a few stores in the week or so after the introduction, and found that, without exception, every Mac’s floppy disk had a garbage name! They were all named something like ”;lkakl;rt;klgjh”, as if someone had just randomly typed characters to see what would happen. Which is exactly what they did.

In the Finder, the startup disk would appear on the desktop, in the top-right corner, ready to be opened. The Finder would initially select it; once selected, typing would replace the current name, following the modeless interaction model that I had learned in the Smalltalk group from Larry Tesler. This meant that whatever anyone typed when they first came up to the Macintosh would end up renaming the disk.

On the early Mac, just typing with any item selected renamed it, which caused all sorts of trouble.

The eventual solution for renaming that survives until today was: click to select and then click again to rename… but don’t click too fast, because that’s double-clicking, and that means something else. Windows, starting in Windows 95, did something similar, but also put rename under F2 – so at least you didn’t ever have to wait.

I liked the emergent behaviour from some graphic apps which put rename under ⌘R. It’s not that hard to make Finder work that way – see below – but I have always been curious why Mac or Windows didn’t steal this solution.

(Added later: People reminded me that of course Enter also renames, and does so immediately. I wonder why it slipped my mind in this context – possibly because in any other list or similar place, Enter would be the equivalent to opening? Maybe I’m discovering in slow motion how unusual Finder can be in its details compared to conventions we established after.)

“We made it be ok by being bored and fixing stuff”

I have been thinking about this a lot since the pandemic, and Rob Napier on Mastodon summarized this really well:

I spent a lot of time in the 90s working on Y2K. It wasn’t a huge panic. It was just a slice out of everything else we spent auditing code. It wasn’t “spend 80 hours a week fixing this.” It was just boring. Incredibly boring. And we made it be ok by being bored and fixing stuff.

And the one thing I never thought would happen was that people would say it was never a problem. Oh good grief, it was a problem. All over. We just fixed it. Like we thought grownups should do when there’s a problem.

There are some good responses to the post and the original post it quoted. This one was brilliant in its vulgarity:

My analogy for this is that I work to maintain a kind of public sewer system. You never think about sewers... until you’re up to your neck in shit.

This isn’t just about Y2K and COVID, of course. It’s also about the invisible work of people who make well-behaved menus, and all the other things like that.

“Not everything that can be counted counts, and not everything that counts can be counted.”

An absolutely fantastic post about software nudges and pop-ups by Mike Swanson:

If you’ve ever read about “choice architecture” and nudging, this will feel familiar. The modern language for it was popularized in the late 2000s, and the core idea is simple: how choices are presented changes what people do, even if nothing is technically forced.

Then product teams go one step further. Instead of just shaping choices, you can shape timing. Prompts start showing up in the middle of workflows because that’s when the user is “most engaged.”

The industry also has a whole discipline around persuasive design and how to move someone from intention to action with prompts, friction removal, and well-timed triggers. B.J. Fogg’s behavior model is one of the more cited frameworks in this space.

Some nudges are genuinely helpful. But the same machinery that helps you discover a feature can also be used to push you into something you didn’t come here to do. And once the machinery exists, it gets reused.

I am finding myself wanting to quote most of it.

You cannot easily measure the resentment. Or the rage clicks when they smash a button to dismiss another “did you know” pop-up. You cannot easily chart the moment a user thinks, “I used to like this product, and now it feels needy.” You cannot easily quantify the slow erosion of trust.

I have long been frustrated by how the “growth” interfaces haven’t really evolved past cheap and loud pop-ups and defaulting to “let’s just show it.” One of the behaviours that bother me a lot that’s not listed in the post is, for example, installing an app and receiving one or even more “here’s what’s new” onboarding callouts. Hey. I just installed you. Everything is new.

Anyway, maybe one more quote:

Optimize for trust, not just return visits. Short-term engagement can be increased by annoyance. Long-term loyalty is harder and more valuable. The best products I use don’t constantly remind me to use them. They quietly do their job so well that I come back when I need them. That’s what tools are supposed to do.

Worth reading the whole thing.

“Fourth reason: Map makers are lazy”

A wildly fascinating 12-minute video from the always-hilarious YouTube channel Map Men about the reason for a surprising black spot that could be seen on Google Earth until 2012.

Reading the Wikipedia entry after watching the video adds extra color to the mystery, turning it more squarely into a “software quality” story:

Some scientists were initially skeptical that such an error could exist, since a signature was present in various global terrain data sets, such as the bathymetric data from the General Bathymetric Chart of the Oceans, which reported an elevation of 1 metre (3 feet) over the location of Sandy Island. Some data sets derived from satellite imagery indicated that sea surface temperatures were absent in the location, suggesting the presence of land.

“Dwarf children die from embarrassment at not being dressed at age 2”

I saw this screenshot the other day (link):

I never particularly liked those “cute” app updates that were all the rage some… 10 years ago? Or app updates that are too generic. I always felt the updates should be informative, and I occasionally like seeing what’s actually being fixed, and sometimes learning from it.

The post above is about a game called Dwarf Fortress that I have never heard of, despite it going on since 2006. In that game, actual descriptions of bug fixes often feel better than those creative app updates. Some examples:

  • Zombies start conversation with necromancer adventurer who tries to sleep in their house
  • Cats dying for no reason - alcohol poisoning?
  • Giraffe is trainable for war
  • Added mouths

PC Gamer some fun ones in 2016, or you can just go to Dwarf Fortress Wiki and explore on your own.

The game seems fascinating, by the way.

“Before I knew it, I had four damaged sockets and three bad cables.”

Speaking of hardware: Always loved this 1998 Australian story (magazine scan or an easier-to-read transcription) of a very particular computer virus that did not require any software to spread “like a Sydney bush fire”:

Now it all became clear. One of the female sockets must have deformed when I first reconnected the CD-ROM burner. This forced the two pins into the same hole and shorted them out. Later when this cable was plugged into the JAZ drive, the pins, now bent to go into one hole, deformed the female connector on the JAZ drive. Again pushing the separating plastic over the hole. Plugging another good cable into this newly damaged socket caused the pins of the new cable to be forced together and short, and when this new cable was inserted into the good SCSI socket on the new JAZ drive it did more damage to it. Before I knew it I had four damaged sockets and three bad cables.

I believe the cables and sockets looked something like this:

The story ends with:

I am only glad the [hardware] virus was contained and did not spread to the rest of the world! Can you imagine if this sort of thing happened in a big computer assembly plant?

Turns out, it did actually happened at a computer assembly plant, in 1997.

“An extremely minor technical problem”

A fascinating deep dive look at one of the most well-known bugs in computing history, the 1993 Pentium FDIV bug. Ken Shiriff actually grabbed a microscope to analyze the processor and mapped out exactly what happened on the hardware level, and the details of Intel’s (surprising) fix.

Also, an interesting detail of what ended up being Intel’s self-own:

The problem might have quietly ended here, except that Intel decided to restrict which customers could get a replacement. If a customer couldn’t convince an Intel engineer that they needed the accuracy, they couldn’t get a fixed Pentium. Users were irate to be stuck with faulty chips so they took their complaints to online groups.

“All comes down to one pixel”

When home computers were new, there was this enduring myth of “killer poke.” POKE was a pretty low-level BASIC command that allowed you to write any number to any place in the memory, as there was no memory protection. From that developed a set of myths of the right magical pairs of numbers that could be input and cause permanent damage to the hardware of the computer, shared in nerd circles almost like campfire stories.

Wikipedia has a pretty dry set of those. The most exciting one there is annotated with [citation needed], and the message seems to be: by the 1980s, this was no longer possible. Even in the earlier version of this idea, Halt and Catch Fire, the “catch fire” was an exaggeration. Before then? Sure, I bet some user actions could damage the computer, but computers themselves, with their high-voltage vector CRTs, electromechanical parts, and even liquid mercury tanks early on, were not that hard to damage.

Unsurprisingly, there are more modern versions of “killer poke,” too. At this point, the best they can do is crash or hang your operating system, but they are still chased, and coveted, and mysterious.

This 10-minute 2021 video from Mrwhosetheboss is a fun story of a wallpaper that could crash your Android OS. I’m not going to spoil the surprise, but it’s not what I expected – although the moment you see the wallpaper in question, you might figure it out.

It’s a fun video, and of that good kind that actually teaches you something.

“The only way to win was to cheat.”

A 6-minute video from JHR about the 1980s British game Jet Set Willy, a big prize for its completion, the bug that made it unplayable, the copy protection, the hackers, and the mess of it all.

Sins of our Finders, pt. 3

This appeared when trying to delete (even when trying to Delete Immediately, skipping the trash altogether):

Same thing right after, when trying to tag some existing items, for which I don’t imagine any new space should be necessary:

Also, why are these dialogs so different?

I feel like not so long ago there were literal books making fun of bad dialogs like these.

Reported to Apple as FB21509633.

“Every time user pressed Enter at a frozen interface screen”

I have never before heard of this story of an absolutely botched deployment of a new accounting system at the British post office, and “the widest miscarriage of justice in UK history.” More on Wikipedia:

Between 2000 and 2015, 736 subpostmasters were prosecuted by the UK Post Office, with many falsely convicted and sent to prison. The subpostmasters were blamed for financial shortfalls which actually were caused by software defects in the Post Office’s Horizon accounting software.

Some of these bugs sound absolutely horrendous, and remind me of Therac-25:

The Horizon IT system contained “hundreds” of bugs. Some of those that came to light were named after the post offices where the bug first occurred. These bugs included: the “Dalmellington bug”, where the system would enter repeated withdrawals in the ledger every time the user pressed Enter at a frozen interface screen; and the “Callendar Square bug”, where the system would create duplicate database entries in the ledger.

This bit feels absolutely crucial and it seemed to me we have learned this lesson decades ago:

And while the technology had changed, the contract between the Post Office and subpostmasters, who owned their own businesses but were agents for the Post Office, remained the same. It stated that any accounting shortfalls were the responsibility of the subpostmasters unless they could prove otherwise. But without the chain of evidence created by paper-based accounting methods, proving the losses were not their fault was near impossible for many.

Fonts have bugs, too

You might not encounter them often in polished fonts unless you’re knee-deep into typography, but: fonts have bugs, too.

Paul van der Laan on Mastodon:

Did anyone ever notice that Avenir LT has some serious errors in the descender lengths of p and q in certain weights?

Florian Hardwig adds:

It’s one of the things that got revised in Avenir Next. But it’s bonkers that it hasn’t been fixed in the “legacy” Avenir that’s still being sold – and bundled with Mac OS – after all these years.

Downthread there’s an original Avenir drawing that for some reason I found very evocative:

“It’s hard to do a drive-by on your feet.”

Perhaps the only ever musical that’s about a buggy piece of software. From the inimitable Cabel Sasser, this 2006 video about Saints Row, with three songs and a goddamn reprise at the end.

It’s very good.

my car door’s freaking out
it seems to be forever in the concrete barricade
I wonder how I’m ever gonna drive away
this really is isn’t my day
the sparks are flying
people dying
metal frying
and I wonder if there’s more to life
or if I’ll find that this is really it
this game is a piece of work

“Just 3 days before the deadline, I discovered something horrible.”

A really fun 2021 story by Fabien Sanglard at the perfect-for-me intersection of bugs and typography.

In 1991, just days before the final deadlines, Akira Nishitani, one of the graphic designers of the absolutely seminal arcade game Street Fighter II realized they misspelled the world “Warrior” as “Warrier.”

The typo was there for months and no one noticed. But the moment it was noticed, the graphic ROMs were already burned and impossible to change, and the code was due in three days.

What would you do? I’ll let you click through to read, but I really enjoyed this short story.

“How can I delete and add to library at the same time”

An absolutely eviscerating 18-minute walkthrough of Apple Music for macOS Catalina, from a few years ago. More funny than anything else, but a reminder to test the “boring” edges of your app – like a state with a lapsed subscription, or coming back after a few months.

There’s no way to drag and drop. […] If I want to add this to here, I have to go through this bullshit, and when I do, it takes seconds again.

Also, an ode to a well-functioning back button, and well-behaving loading states. Those things add up so quickly.

(My debugging brain understood what populated the confusing History entries – I bet it was the early play sequences that went through a bunch of stuff without playing.)

“OK cool now we can ship the game phew. But why did this EVER work?”

Tom Forsyth wrote about a fun bug in a Half-Life 2 reissue, of a particular flavour I have never heard before.

So I started it up, selected new game, played the intro section. It’s a fairly well-known section - you arrive at the train station with a message from Breen, a guard makes you pick up a can, and then you have to go into a room and... uh... I got stuck. I wasn’t dead, I just couldn’t go anywhere. I was stuck in a corridor with a guard, and nowhere to go. Bizarre.

“…and then the system crashes.”

From Nina Kalinina’s excellent revival of a forgotten 1983 GUI, a discovery of a hilarious accessibility bug:

VisiOn loves to beep at the user. It beeps every time a menu option is chosen or an on-screen button is clicked.

If you are tired of the noise, you’d appreciate that Application Manager has an option to replace the sound with a “visual beep”. It is implemented as a flashing area of 32x16 pixels around the mouse cursor. Every time the flashing is about to happen, an image “below” the cursor is preserved in RAM to be restored after the “visual beep” is over. However, the memory allocated for this bitmap is never freed. It takes between 200 and 1000 clicks to fill the RAM with useless copies of the mouse cursor, and then the system crashes.

If you have never heard of VisiOn, The Digital Antiquarian has a fun walkthrough that also happens to be the first chapter of an excellent series about the history of graphical user interfaces.