The task manager app Linear does something interesting I have not seen before. In the keyboard shortcut tooltips, it highlights the modifier keys you already pressed, to give you confirmation you’re on the right track:
I think this is nice, particularly given that the modifier key situation is kind of a mess, and particularly if you consider some keyboards present their modifier keys like this:
I think it’s valuable to offer a connection between your fingers touching keys and something happening onscreen in real time – similarly how the blinker arrow in your car pulses exactly at the same rate as the sound it makes, to help you connect the two.
However, Linear does not do this in all the contexts:
While the first two videos might be simply bugs, I am not sure about the last three. It’s entirely possible this was done intentionally because these surfaces – the menus, the command palette, and the keyboard shortcut pane – do not support actually invoking the shortcuts. (Pressing the listed keys would not actually achieve anything.)
But I still wonder if this was a good call. One of the most important things for any new systemic pattern is building trust: making sure it’s consistently applied in all the nooks and crannies so that the user can understand what it does, learn to rely on it, and form the habit. Just one place where it doesn’t work might make it easy to just give up on it altogether.
Perhaps this is an example of how hard it is to design a cohesive system, which in Linear’s case is compounded by the fact that a lot of shortcuts start with regular keys like G and O and P, exacerbating focus issues. Either way, it’s delightful to see someone doing something new in this space.
It’s a human story whose beats might be familiar to some of you: a long software project that ultimately failed despite the enormous effort. And it did so in an industry – high-budget videogames – where failures might feel particularly brutal: the projects take multiple years but the defeat can be swift, the servers get shut down and the game instantly evaporates, and instead of employees being reallocated to other games, the studio gets disbanded and people let go.
There are some nice moments in the podcast’s interviews with about a dozen people, hearing about personal pride and responsibility, working together with others, and a certain camaraderie not just with other people, but with their software that develops:
I think the best part about it was being able to play with my coworkers and then cutting loose, and being silly, and really enjoying what we made together, as a unit. That experience alone made it worth it.
There are also questions about the management’s role in all of this – this part we might never get to know fully – and the worry about game preservation.
This is not mentioned in the podcast, but it seems widely understood the story is about Concord, a AAA live-service game that is rumored to have cost a staggering $400 million dollars and taken 8 years to develop, only to be shut down mere 12 days after its launch in the late 2024. (AAA means a blockbuster with highest budgets seen by the industry, and live service means a game like Fortnite, which is expected to make money over time from add-ons and upgrades.)
Learning about Concord’s macro view adds a lot of color to the boots-on-the-ground podcast above, but one has to be careful exploring it; the online discourse about the game felt similar to the 2016 reboot of the movie Ghostbusters where sure, the product might have been subpar, but also a lot of commenters seemed eager to arrive to the conversation carrying truckloads of bad faith, gatekeeping, and misogyny.
Some good articles? Keza MacDonald in the Guardian has a nice summary of the whole situation:
This is a brutal sequence of events. Sony bought the makers of Concord, Firewalk Studios, in 2023. Concord had been in development for eight years, and it was an expensive game, with bespoke cinematics and a long-term plan that would have cost $100m or more to develop. In its two weeks on the market, it sold fewer than 25,000 copies, according to estimates. This is a shocker, even compared with the year’s other bad news for developers and studios.
MacDonald also adds:
Speaking personally, I do not want a game that takes years to play. I want one with something to say, an experience to impart, and one that eventually ends. A game whose artistry comes before its business model.
This is partly a matter of taste. Self-evidently, there is an enormous market for live-service multiplayer games; it’s just that most of those people are already playing one. I highly doubt that there are untapped millions of players desperate for a hero shooter or battle royale game who just haven’t found the right one yet. It’s time that publishers try something new instead.
With so many games now taking close to a decade from the beginning of development to release, we’re starting to see the financial and creative consequences of an overlong development cycle. Spend too much time in development and ideas that were once novel are no longer in vogue. Furthermore, the time and money spent over those years has to be recouped somehow, which leads to decisions like the $40 cost of entry for Concord when many of its peers are free to play.
The cost of coming late to the party means you must bring something new to the table. Unfortunately, Concord is neither particularly innovative nor content-heavy. That said, it does have a level of polish at launch that was often absent from its hero shooter peers when they were first released. Indeed, Concord’s weekly animation story drops are fully motion-capture, and Firewalk’s time spent on crafting its lore has helped secure Concord an episode of this winter’s video game animation anthology series, Secret Level.
But well-established hero shooters like EA’s Apex Legends launched almost bare bones and still managed to make a splash thanks to its intriguing central concept which combined hero loadouts with a battle royale match format. Valve’s Deadlock doesn’t even have finalized assets or art but has still caused a huge burst of excitement among the PC community, thanks to the way it changes up the classic 6v6 hero formula with its heavy lane-and-minions MOBA [Multiplayer Online Battle Arena—ed.] mechanics. By contrast Concord appeared with an all-too-familiar offering and, frankly, the time spent on finessing its presentation – the graphics, motion capture, performance, and so on – likely lead to a later release date which in turn meant it lost valuable time establishing itself among its peers. If it had been released four or five years ago, when the PS5 first came out, maybe its launch would have been an entirely different story.
I think this is important to quote on this blog that often talks about “finessing” and implicitly – or sometimes explicitly – about the value of taking time to get the details right. We can’t forget that there are such things as overdesigning and overproducing, and that ultimately there is no way to polish your way out of something that lacks a soul.
I am generally not a fan of typewritten art, because at some point it all starts to feel a bit same’y, and the gimmick of using a typewriter as a paintbrush wears off pretty quickly.
But these drawings by German artist Arno Beck caught my attention, because it feels like they playfully remix three eras:
overtyping keyboard art (early 1900s),
the sort of photorealistic smooth shading I most associate with ASCII/ANSI art (1990s),
big pixels from early home videogames (1980s).
In case this interests you, in 2018 I gave a 46-minute talk called “The abridged history of having fun with keyboards” that’s a (hopefully fun) walkthrough of this whole space:
I still use Sublime Text for all of my programming and all of my newsletter-ing. […] The app is simple and superfast; I have it set up exactly the way I like it […], and it’s difficult for me to imagine ever switching to anything else.
Here is a piece of software as sturdy and obedient as a cast-iron pan.
I don’t know who develops it and I don’t care. All I know is that I can place my text cursor and read the surrounding code without a bombardment of popovers, pop-unders, pop-left-and-rights, pop-inlines, pop-in-and-out-too-fast-to-sees. […]
The perfect dev stack is a collection of software that each does one job and doesn’t suffer main character syndrome. I want to code, I’m not looking to make lifestyle choices. I don’t want a bloated everything app. Don’t get me started on the “unified toolchain” plague! Show me the latest VC-backed build tool and I’ll show you ten lines of PHP that does a better job.
If you’re fed up of the absolute state of things, Sublime Text still works.
I do care who develops good software since, at the very least, I want to give them credit. This is the best I could find, if you too are curious. It was prompted by someone asking:
I’ve been a Sublime Text user for over a decade, and now a Sublime Merge user, too. But it occurs to me that I know almost nothing about the team/company behind it.
I wonder if this is a nice example of the (quiet) posture of the company matching the (utilitarian) personality of the software it is making.
iPhone’s home button and then the swipe up home gesture are so important and well done that they probably need to be covered as Unsung Heroes, but I wanted to mention something else today as we’re revisiting the whole “app icons in squircles” story (my most recent post + Louie Mantia’s post).
The first iPhone in 2007 put apps as squircles on the home screen, and it also put a matching shape on the home button:
The shape on the button didn’t survive very long. It was removed starting with iPhone 5S in 2013, which introduced Touch ID – I guess it wasn’t possible to print the icon atop the button without sacrificing the finger detection accuracy. Then, in 2017, the button itself disappeared with the iPhone X.
The iPod Touch was the iPhone without the cellular radio – it was made from 2007 to 2019, supported all the same apps as the iPhone, and sported a home button with a squircle up until the end. (Ironically, despite its name, it never got a Touch ID.)
But there was another iPod that entered the app fray. It was the iPod Nano, whose last edition from 2012 had a home button – except it looked slightly different:
What was the reason? I don’t know if Apple ever explained it, but I believe the idea was that this iPod did not have downloadable apps, nor the App Store, nor even iOS. Those were all built-in apps, and I imagine Apple wanted to indicate visually that they’re different. Because it wasn’t just home button. The apps – eight of them, across 2 pages, although you could rearrange them! – all sported circular icons:
I don’t know if this approach was in any way effective, but I found it a funny little footnote.
Some years ago, the inimitable channel Technology Connections posted a 17-minute video about the peculiar design quirk of ceiling and room fans – they usually order their options Off → High → Medium → Low rather than the more natural Off → Low → Medium → High. The video is a bit off topic for this channel, but check it out if you’re interested how sometimes weird physics considerations influence design in the real world:
In the video, the host also talks about the more natural order that typically looked like this:
I wonder if you recognize this kind of an interface. I have a distinct memory of it from radios (where “zero volume” would mean “off”) and from TVs/early computer displays (where “zero brightness” meant “off,” too). There was something special about these controls that stuck in my memory, motor and otherwise: this tangible, heavy click when you ventured outside or back into “off,” almost as if you had to break the interface itself.
I thought this, too, was a convention from an old analog time. Yet, I keep occasionally finding the “the first notch is special” interfaces on screen.
Sometimes, they are pretty literal translations of the concept, like when you adjust the key repeat rate in macOS:
Or, similarly, when you choose the dock magnification:
But sometimes they are a bit more conceptual. Here, Nova treats the first notch of the zoom scale as a “list” option:
Or: The new horizontal tabs in Chrome allow you to resize to whatever width you want. Below 125px, however, they snap directly to the minimum 55px width, a one-off “column view” with streamlined and purely iconographic controls:
These all have pros and cons, too.
On the con side, just like the fan or volume controls, they miss any memory since turning them off physically moves the knob away from any “value”; if on/off was a separate button, you could just leave the radio at your preferred volume and never touch it again. They also won’t be as discoverable as a separate onscreen toggle would be. (Here’s an example of a more classic treatment from the Nothing Phone.)
Pros? They are compact. They allow you to change from “off” to a value in one quick gesture, skipping an explicit “on” step. You could even argue they are simpler also in a visual sense.
But also, they are a bit… magical. I don’t know. That’s what to me unifies those old physical controls and their newer digital equivalents – they’re a little extra, a little different, a little special. They break the monotony of a predictable interface built out of boring, identical components. (Although, sadly, not a single onscreen example above uses haptics!)
And I think that’s kind of nice. Not just in the very functional sense of breaking up the UI through shape coding etc., but also in a sense of making UIs more interesting.
Speaking of volume, macOS used to show it as a sort of a HUD, using a treatment that borrowed from both the “first notch is special” radio knobs, and from early onscreen interfaces in TVs:
But after 20+ years, macOS Tahoe changed it so it now looks this way:
I can understand the argument that this is more consistent, and that it even teaches you – by proximity – that Control Center is what these controls call home. Yet I can’t help but think (and it seems I am not alone) that this is so boring and exactly how Windows would approach things – and that this change, just like the squared icons, is how macOS lost one more bit of magic.
On the positive side, here’s a delightful interaction from macOS. I can easily maximize the window to take up half the screen, but the moment I start dragging it, it recalls and nicely restores itself to its original size:
macOS designers correctly figured out that the window being maximized or half-maximized is a state – but it has to be a state dressed up as a size. The button entry point is the “state” version. But on the way in, there is also a more natural “size” version: you can have the window snap and maximize to half screen when you drag it to the right edge. And on the way out? You just saw it. You don’t have to switch the state to “non maximized” first, and you don’t have to restore to the original size by hand.
Here’s a bad example – one of the macOS’s horrible settings pages:
So far, it seems good. Some of the toggles are on, some off. You not only see a position of the switch change, but also the track under the switch is a different color to help you disambiguate. Nice.
But now look what happens when I toggle off the second option, which the third and fourth option rely on:
Processing this dialog visually, does it look like “on, off, disabled off, disabled on,” or does it look like “four toggles, each one inexplicably with a different shade of gray”?
There are many solutions here: some visual, some IA, some systemic. Also, I use the graphite accent color, which somewhat exacerbates the issue, although it’s there with any accent color.
But I wonder if one of the challenges here is that someone thought it’s important to show the state of the toggle even if it’s disabled, and everything else followed from that. This feels similar to the dark mode essay in that there will always be someone making that argument, and that argument will always feel stronger, because it will feel like it’s backed by logic. The system will make sense as a diagram. Each of its parts will come from a logical conclusion. So did the tri-state dark mode toggle. Or the Power/Sleep/Wake keyboard buttons. Or Abort, Retry, Fail in DOS.
Arguments for systemic completeness are always going to be easier to make than arguments for thoughtful simplicity.
I sketched two possible solutions. They’re not the best ones, and you might recoil at them, since either one is a compromise. But that’s the point.
On her blog, Lea Verou makes a case that each user-facing website dark-mode toggle should only ever show two options, but in a smart way.
The challenge is that any dark mode toggle needs to actually accommodate three options: dark, light, and the default “whatever the system says” (which can be always dark, always light, or change with the time of day). Many toggles simply pass that complexity onto the user:
I want to get something out of the way: I don’t think Verou’s articleas an article is fully successful. I feel like it spends a great amount of words to explain something not entirely as complex, and even the interactive playgrounds felt slightly too rigid and altogether confusing. If you care about (interactive) explainers, it might be an interesting case study in and of itself.
But I am very much much on board with the proposal and the line of thinking it represents. Verou suggests a “smart” dual state toggle, which still allows the website to follow the system, but shoves the complexity of the “whatever the system says” branch into the crevices between visible UI. Here’s how I understand it:
The smart toggle only has two options: light and dark. Mechanically, clicking or tapping the toggle brings you to the opposite option. Simple.
If your new option is the opposite of system (e.g. you switch the page to dark mode if your system is in light mode), it will stay in that theme forever, no matter what the system does in the future.
If your new option is one that currently matches the system, it will then continue following the system in perpetuity (e.g. it’s back to the default behaviour).
This toggle will feel compromised, and you might immediately find some rare use case it doesn’t fully support – maybe attached to an imaginary user, or even an internal user giving you feedback in person. But Verou is absolutely correct in her insistence to fight through that:
Tri-state toggles are implementation-driven UI. One of the most common UX mistakes is designing UI around the underlying data model instead of user goals. Good interfaces abstract away the underlying model and expose a model that aligns with user goals (unless of course these happen to coincide, which is rare).
Now, it’s just a dark mode toggle. It might not seem like a difference between a smart dual state toggle and an explicit tri-state toggle is that much. But:
“Whatever the system says” is not just one extra option. It’s also one extra weird option. It doesn’t feel like the other two. It’s seemingly repetitive. It’s often unclear what it does before clicking. It’s not obvious where to put it in order. Verou doesn’t mention this in her post, but even just seeing the word System next to Light and Dark feels complicated. (Auto is slightly better.) The cognitive load here might be larger than it seems.
What is an interface if not a collection of a million challenges, each one seemingly insignificant on its own? Trivial things add up. One compromise here and one cheap decision there, and soon you’re talking real money.
Thinking deeply about something like this gives one practice for dealing with complexity elsewhere, and facing even more difficult challenges where the stakes are higher and the compromises larger.
A similar example might be that of PC keyboards in the late 1990s, which also exposed system complexity and pestered people with Power/Sleep/Wake keys:
Computers do not do that anymore, simply having a smarter singular power button, piped to a more sophisticated logic underneath.
From Marton Barcza at TechAltar, a good 12-minute video analyzing what went wrong with the famed Live Tiles that Microsoft was pushing throughout most of the 2010s:
Now, among Windows Phone fans the pervasive opinion is that Live Tiles have failed because Microsoft did a poor job with them, which I think is at least partially true – after all, even many key Microsoft apps like Skype had broken Live Tiles half the time, the Windows 10 start menu was filled by Microsoft with Live Tiles that were clearly just animated ads rather than showing you something actually useful, and the company of course never built out any of their advanced interactive concepts either.
But while all of that might be true, the fact that every major company has walked away from this idea and nobody else has picked it up since, means that there probably are more fundamental problems with this idea. And I can think of three distinct ones:
user experience,
form factors,
and horizontal integration.
Barcza goes on to talk about some specific interactions and problems, and arrives at the conclusion that Live Tiles ended up at this unpleasant intersection where they’re tried to be icons, widgets, and notifications all at once, not doing a particularly great job at either task. That, and there were also challenges with the design primarily being mobile-first, and struggling surviving a jump to a large screen. (Live Tiles were abandoned in 2017, at which point desktop Windows reverted back to what it was before, and the mobile/tablet lines were altogether disbanded.)
What I found interesting in watching this today is that it feels Apple has made some similar mistakes in their Liquid Glass approach and wider platform unification desires (see: macOS Settings). Both these and Live Tiles attempted to create A System Of Systems, and both ended up occasionally feeling like they awkwardly crowbarred some wider concepts into places where they didn’t truly belong.
If it helps with your further research, I understand Live Tiles were part of a bigger UI effort called Metro and started in earnest with Windows Phone.
Minimaps are an interesting UI element because they often feel very exciting – something about things being small, or responsive, or maps just being cool? – but fail to actually be useful.
I find minimaps for coding particularly tricky because, at least in my world, code all looks very much the same from far away. Seeing a thumbnailed/greeked version of it felt just like a more expensive and distracting version of a regular scrollbar, without any benefits.
But Xcode does something interesting. It allows you to use MARK to create a sort of a “header” for the minimap anywhere you want:
The minimap then shows those headers not greeked, but as human-readable text:
I thought this was clever, allowing you to see the bird’s eye view of the code not just in the most obvious visual sense, but also as a sort of “table of contents,” adding so much more utility.
This, of course, is technically no longer a “zoomed out view” but then again, it’s not that there is some sort of rule that it has to be. As a matter of fact, quite the opposite; it all reminded me of the famous London subway map by Harry Beck, which also broke the expectations in a similar way.
The original, geographically accurate map of London’s tube looked like this:
Beck decided to take liberties with the geography and reimagine the map as a diagram to help the travellers, and ever since he’s done so in 1933, many transit maps followed suit:
Sopwith is a 1984 videogame made by David L. Clark for the original, seminal IBM PC model 5150. It sports the distinctive 4-color CGA palette and an equally distinctive PC speaker soundtrack.
It’s also one of the oldest videogames still in active development, and I was surprised how enthralled I was learning about it.
(First of all, you can play Sopwith in a browser. Choose “single player” and then “novice” first for the game to tell you about its unusual keyboard control scheme.)
The current maintainer of the effort is Simon Howard. He wrote about Sopwith’s interesting history; I appreciate this kind of approachable and caring preservation of obscure titles. The history is worth a read.
From that, I learned a fascinating factoid. The game was intended as a demo for networking hardware, and the original author didn’t realize the game was “in circulation” for many years:
Intended as a trade-show demo, it’s unclear how Sopwith escaped to the general public. David L. Clark didn’t even discover until around 2000 that it had “gotten out”. Little did he know, Sopwith had been circulating for years in collections of early games for the IBM PC. Only a couple of years after the first version was released, ads were appearing in magazines like PC Magazine advertising Sopwith for sale as part of collections of games for the IBM PC
The modern edition started by Howard is called SDL Sopwith (SDL being a cross-platform graphics library):
SDL Sopwith is directly derived from the source code to the original DOS versions, and still includes changelog comments that date all the way back to 1984.
What I particularly liked about the contemporary Sopwith is its guiding document/philosophy page, also worth checking out in full. Here are some choice principles:
Sopwith has a long history that deserves to be honored and preserved. By default, the game should always play like the original DOS version. That means the gameplay in particular should be the same, without any significant differences. Someone who has just discovered the project should find it to be a delightfully accurate recreation of the game they may have played when they were younger. […]
Some new features can be enabled by default, as long as they are subtle, unintrusive, carefully considered and can be turned off. An example is the medals feature.
The game will never try to be “something it’s not”. This means that it will always have four color CGA graphics, PC speaker sound effects and a low resolution display. It will never add (for example) hi-res sprites or 3D models, digital sound effects or MP3 music. The goal is to be “a great old game” rather than “a mediocre modern game”.
New features should be fun and recognize the comical aspects of the game. Features should be carefully considered before being incorporated, not just added arbitrarily and thoughtlessly.
There is something in all this that I feel a lot of software could learn from – not just vintage games. I appreciated Howard being thoughtful about growing Sopwith without forgetting its roots, but also with understanding that some things have changed since 1984. You could imagine remixing “The goal is to be a great old game rather than a mediocre modern game” to something like:
Better be a great focused app than a mediocre sprawling app.
A strange thing happens when you press Enter on an empty item in a list in most text editors – the entire list item disappears:
This feels counterintuitive. Isn’t Enter for committing and adding more things? Wouldn’t Backspace be the right key to press to break a list?
Yes, and no. I am not sure who invented this pattern (I spotted it first in Word 95), but that someone understood a strange interaction contract existing in text editing – Enter is actually an escape hatch. In text editing, no matter where you are, you can always press Enter multiple times to just create more room for writing.
In an app that doesn’t cancel a list on Enter, you can face a terrifying moment where you get stuck in a list, and getting stuck is never fun.
This principle feels so useful that I see more and more apps apply a version of it for other things. For example, in many modern text editors pressing Enter after a headline returns you to regular text, just so it’s not as easy to get stuck in a headline style:
It covers some of the same areas we recently talked about: diacritics and Polish S (and a fun video about English conventions from a while back), but it tackles them on a higher level. McManus talks about how people express themselves via their usernames, how that changes in various countries of the world and for what reasons, how it intersects with some UI considerations, and how people use it creatively – and also, sometimes, abuse it.
This is the K-pop star IU. Uh her Instagram handle is “dlwlrma.” And I think at first this maybe seems already like complete hyperreality, like it’s bearing no relationship with her Hangul name, or even with her stage name. But actually, I think this is at the third stage of Baudrillard’s theory because really “dlwlrma” is Lee Ji-eun’s Hangul name typed out on a Korean keyboard but backwards, distorted, while that keyboard is set to render Latin characters, almost like a cipher. And then her display name is her Hangul name typed out with one of the characters changed, so it’s like a pun.
I didn’t feel the talk stuck the landing – in the end, I wasn’t very sure why the decision that was made was made. But there’s a whole lot of stuff before that was fascinating and thought-provoking.
Mac’s operating system has a peculiar way to install apps. An app typically arrives in a file with a .dmg extension (it stands for “disk image”; my brain always reads it as “damage”), which upon double clicking becomes a kind of a drive. You go inside the drive, and there is the app icon.
But the journey isn’t over. While you can run the app from the virtual drive, the drive will eventually disappear after the reboot – or if you eject it – so it’s in the app’s interest to suggest a more permanent home for itself.
The way many apps choose to do it is by creatively combining a few of Finder’s options. Those options are available for everyone, in any folder, but perhaps not as known. The first stop is removing the toolbar and the sidebar, and any other bars. The second is switching to the icon view, and picking the right window dimensions. What’s needed next is a link to the Applications folder. The last ingredient? A custom background that’s placed underneath and creatively uses the fact the size and the position of all the icons are known:
After this makeover, the Finder window resembles almost a specialized app window, and you can use all of this power to… tell the user to drag the app to the permanent folder:
There are nuggets of something good in this flow – dragging an app icon to Applications is consistent with the other gestures you use to navigate the Mac, and teaches you that the app is just a file that you can place anywhere, or trash when done.
Overall, however, it feels quite a bit confusing, leading to spurious dangling drives, extra confusion, and attendant problems like these:
But I am not here to relitigate the flow itself, but to take a look at a few of those customized Finder windows. They became, in a way, a particular design playground with just enough constraints to make it interesting: an app icon, an Applications avatar, an arrow between the two, a typical size, and a bitmapped background tying it all together.
(Other historical playgrounds that got many designers excited: a calculator app, a weather app, a Twitter client… and outside of pixels, a watch face or a chair.)
Below, I went through many windows to find what I thought were the most well-made or interesting “drag to Applications” treatments.
The arrows
The first obvious place to start playing is the arrow, which can really be any shape and color… or maybe even not resemble an arrow at all:
An unusual direction
That last window shows that although in Western cultures it’s customary for time and flows to go from left to right, it doesn’t mean we can’t choose a different axis. Here are a few more examples:
More specific instructions
You might have also spotted above that some places aren’t content with the arrow itself, and adorn the window with more explicit text instructions.
Here are more examples of that. This one adds a simple two steps, but also perhaps starts feeling like Arrow City:
This one distributes the two steps differently and tries to cover the clean-up also, so you don’t end up with a dangling drive:
This one has a certain “cheapness” to it, but I find its minimalism endearing – the “link” arrow almost serves as the action arrow, and since you can rename the link itself, why not rename it into a set of instructions?
And this one feels like mad libs. Does this work, or is it more confusing to intersperse (passive) instructions and (active) objects this way? I’m not sure.
Scenes with icons
What I also noticed is a fun way that some of these used the dimensionality of the icons themselves, to place them in “the real world.”
Issues with gestalt
These next few feel like they have some issues – specifically with gestalt – and I thought it might be informative to look at them.
The first one has a very strong left-to-right directionality, and I wonder if people try to drag the left blue folder onto the right one?
This one is an interesting lesson in how versatile arrows can be, but also how tricky it feels if you go against the convention:
This I’ve seen a few times – despite the arrow, this still feels like a 2×2 grid of equally important things, or can also be misunderstood as “drag two items onto the other two items”:
And this is a better example of how to accomplish something the above window botched:
Different mechanics
Not all the apps choose the arrow-drag mechanic, and some are not allowed to. Here are other treatments I particularly liked:
Fun visuals
Some apps go deep on visuals. Here are a few I liked:
A modern app called Inkscape does something interesting:
[The Finder backgrounds] are designed by our users on the website in the about screen content. Held with every major release!
So I downloaded all the major releases of Inkscape to show you:
Today
And that brings us neatly to today. I think Firefox deserves extra credit for keeping their Finder install window beautiful and elegant throughout all these years:
And let’s close this off with a few gorgeous modern examples. Many apps these days come from the App Store and skip the Finder flow altogether, but here are a few that still ask you to drag:
That’s it! But send me more if you have them!
Thank you to Chris Messina for creating the Disk Images collection which I pulled from extensively for this post. Additional thanks go to Jean-Michel Durand, Mindaugas Rudokas, Louie Mantia, Colin, mimi, Jeremy Visser, Luke Dorny, Oskars, and Peter Tripp. The title comes from a reaction to one of my socialposts where I asked people to send me good examples.
If you’re a professional web app, your key shortcut situation is not to be envied. Once the operating system grabs the ⌘ shortcuts it requires (⌘M to minimize, ⌘H to hide, ⌘Q to quit, etc.), the browser has its turn, claiming everything from ⌘R, T, N, L, W for tab operation, to ⌘F, P, O, and S for other things. And then, some input controls inside the browser also need to listen to ⌘Z and XCV, and maybe even A (select all), B (bold), and I (italic).
At this point things feel barren, and some web apps start reaching instead for less common modifier keys (⇧, ⌥, ⌘⇧), and others go straight to no modifier zone, or override those of the above shortcuts that they can. Each approach, of course, has its own set of challenges.
It’s perhaps not a surprise that someone got fed up, and that someone was people working on the project management tool Asana, which did something relatively unique: it promoted Tab to be a modifier key.
The video shows me using Tab+K to like tasks, Tab+Return to open a sidebar, Tab+Q to add a quick task, and Tab+H to return home. Here’s the entire official shortcut list, with Tab shortcuts emphasized:
What’s fascinating about choosing Tab is that the key already has so much to do:
it moves focus to the next UI control,
it indents a bullet point or even just text,
it accepts an autosuggestion or a placeholder (and similar things).
On top of that, repurposing a key to be a modifier key – especially one that already has a job or two – will also have a long tail of strange consequences. And, Tab is only on one side, which could wreak havoc with the ergonomics of keyboard use. (You are, technically, always supposed to use the modifier key with the opposite hand to the hand you’re pressing the main key with.)
But…
I am not ready to hate it quite yet.
Tab is not the worst key to use in this context, as it’s really the only available big key other than Caps Lock, which is impossible to mess with on the web. The other big keys – the spacebar, Return, and Backspace – would be radioactive for this purpose.
The asymmetry issue? Anecdotally, I understand that both right-handed and left-handed people most often use the pointing device (mouse or trackpad) with their right hand, and consequently often prioritize left modifier keys anyway.
Here is how Asana deals with some other challenges:
When you press Tab to move focus around, the action can now only take place on key up, not key down, so tabbing (or, indentation of bullet points) feels slower.
When you hold a regular modifier key and then change your mind and simply release it, no action occurs. But Tab already has a job as a regular key (tabbing or indentation, depending on context), so if you change your mind, something will still happen. This might be annoying. (You can press Tab+Esc or Tab+Space for a safe cancel, but that doesn’t seem very intuitive, especially in a moment of panic.)
An action only on key up also means there can be no repeat when holding Tab. I am not sure how important this is, especially in the context of accessibility.
What’s interesting and I bet the main reason Asana approached it this way, is that Tab is a separate little island, far away from other modifier keys – and thus not just without any preexisting conflicts, but also impossible to confuse with other modifier keys. Asana could have kept all the shortcuts above but substituted Tab with Ctrl on a Mac and Alt on a PC, but those would then be packed among many other similar-feeling keys.
(There is a price for this isolation, as Tab backfires the moment you have to combine it with other modifier keys. Asana doesn’t do it very often – I have only seen Tab+Shift+D, G, and F – but I wish they didn’t do it at all.)
Overall, I’m surprised how positively I feel about it. If you use Asana a lot, I’d be curious how Tab-based shortcuts feel to you. If you work at Asana, I would love to know if you consider these a success.
The only thing that seems to be missing is an option to go back to regular shortcuts if needed, for people who might want it for motor control reasons. (It is possible to achieve that with tools like Karabiner Elements, but that tool is really unpleasant to use.)
Oh, also. Tab+B does this, because, well, “tabby.” Cute.
Speaking of computers that used to stop running if you looked at them funny, a few years ago I wrote about the Monkey app that was there on the original Mac. Many software engineers will recognize the premise – Monkey was just a chaos script randomly pressing mouse buttons and keys during the night hours, and if the computer crashed because of Monkey’s random actions, the team would be able to reproduce it and try to fix it.
I was also inspired to try a Monkey-like approach for something creative. In hindsight, it’s a very Unsung post, so you might enjoy it!
Also, in the post, I showed this boring version of Monkey:
Since then, I discovered a different version with its own icon, perhaps designed by Susan Kare:
(If creative use of randomness rings a bell, here’s also an earlier Unsung post about a different take.)
Contra the previous post, just spotted this “Same settings, new look!” callout in Firefox, on a page I have never visited before, talking about a feature I have never used:
I mentioned this once – when you get someplace new, everything is new. This redesign announcement’s conditions were engineered poorly, because they didn’t even consider people who didn’t use the feature before the redesign.
I keep thinking of the very old computers from the 1940s, 1950s, and even 1960s, where the challenge wasn’t what to do with the computer, but with keeping the computer running. There was a machine called JOHNNIAC which gained a nickname “pneumoniac” because it refused to work on a warm day. On many other computers, there was a daily ritual of finding which of the vacuum tubes blew up and had to be replaced. Some teams had a literal downtime tax; they knew and communicated in advance that 40% of the days the machine would not be up to the task, consumed by tweaks and repairs to bring it just to the state of being ready to do work.
When I look at those kinds of pop-ups and callouts, I think how we’re unwillingly recreating the very same conditions. I deeply believe people are exhausted not just by changes in software, but also constant questions, pop-ups, unnecessary notifications, “STOP 2 END,” “tell us what you think,” emails to unsubscribe from, unsubscribes that don’t work the first time, and so on.
Software should not require the user to occasionally click on buttons just to keep it running.
I wanted to show you a year’s worth of messages from my barber’s software, because this is what software should be.
No spam, no upsells, no growth hacks, no unwelcome cuteness or puzzling verbosity. It’s so curt and straight to the point it should be set in a 1970s Helvetica: The appointment’s tomorrow. Any questions?
Yet we should never forget that the product of work isn’t only the work — it’s also the worker. Doing the work changes you; the up-close experience transforms your capabilities and even your desires. Insights and ideas emerge from that interface, and I believe the agent maestros lose a lot — too much — when they take their big step back.
But I suppose this is just my temperament, which I’ve written about before. I don’t merely want things done; I want to do them.
The limits here are I believe unrelated to precision, and rather to wanting to keep the player within a controlled, designed environment. (We once covered a story of this backfiring horribly, and also talked about skyboxes and streaming.)
The video also made me want to see people – especially designers with less experience slash less baggage than I have – doing a tier list of e.g. common interface elements. Or maybe I should make such a video…
When you learn computer science, at some point you encounter floating-point numbers in all their peculiar glory. Floating-point numbers allow you to store values that are extremely huge or extremely tiny, but that comes with a strange price. The number is still just a number with a regular limited precision, but is accompanied by a floating point – another number that just says how many zeroes to put after or in front.
In effect, when your number is millions, you get a precision of thousands. When your number if billions, you can only count in millions, and so on. This makes intuitive sense, in a same way a billionaire doesn’t care about pocket change. (Go to a floating point visualizer, and you will see you can input 9000004 and 9000005 and 9000006 with no problem, but add one more zero and 90000004 will be rounded down to 90000000, and 90000005 up to 90000008. Bigger numbers get even less precise.)
This has a strange effect when it comes to videogames or graphic software: The further you move something away from the origin of your universe – where X and Y are 0 – the more you have to worry about its internal precision.
This is not a problem in real world. You can send a tiny, incredibly meticulous watch screw far beyond the solar system and back, and it will do fine. But now jump to the digital world, assume Earth is 0:0 – apologies to Copernicus – and now the further away you go, the more the floating point moves to the left, and at some point the precision of the number on the other side runs out; a value that can express billions of kilometers is too coarse to even consider millimeters.
This is a fascinating problem which is visualized nicely in this short video. This is what happens when you move an object with its constant internal precision further and further away:
There are ways around this – you can increase the precision, introduce a “floating offset,” have two precision centers around two floating points, or do a bunch of other things – but each one will cost you. So, sometimes, the best solution is the simplest one: do not allow the numbers to get too big.
And this is why Adobe Illustrator, Figma, and I bet at least a few other tools that promise infinite canvas, actually stop you if you stray too far away from the center. Precision is like atmosphere, the canvas says, thinning out the further you go. We cannot promise your structural integrity will survive going past a certain point, so we won’t allow you to do that.
Here’s Figma, where I at some point the canvas stops following your scroll commands:
The first invisible X value is 131,072 and it’s not a surprise it’s one of these numbers that will look very, very familiar.
It seems like a huge enough value, but if you consider a slide in a slide deck is 1920×1080, it’s not as infinite as it might initially seem. And this is also why – in part – Figma Slides manually wraps you after 20 slides:
I’ve enjoyed John Gruber’s posts about ads appearing on an increasing number of Apple surfaces: the App Store, Apple News, and – soon, perhaps – Apple Maps. (Just for reference, here’s an example of such an ad.)
In a post earlier this week, Gruber likened ads to stickers on laptops, and shared a fun Steve Jobs story:
That’s what those stickers on PCs are: they’re ads. Intel pays for the “Intel Inside” stickers that booger up PC laptop palm rests. Longtime readers will recall that back in August 2007, Apple held a Town Hall event to introduce new iMacs and some iLife and iWork software updates. In a post-event Q&A (imagine that), Bob Keefe of Cox Newspapers asked “Can you say why you all are not participating in the Intel Inside program, putting the stickers on your new or previous Macs?” This question was so absurd from the perspective of those who covered Apple closely that it prompted outright laughter. […]
The 2007 exchange went as follows:
Keefe: Why are you not participating in Intel Inside program and not putting stickers on your Macs?
Jobs: Uh… what can I say? We like our own stickers better.
(In case it’s not clear, this was a joke; Apple didn’t and doesn’t put any such stickers on their products. They instead used to include Apple logo stickers in boxes.)
I feel like a variation of Zero-One-Infinity is a good rule of thumb for ads, too. From the perspective of users — and probably developers — zero was the best number of ads for Apple to show in App Store search results. One was worse but acceptable. But now that they’re showing more than one, they’re on their way to infinity. They’ve started down the slippery slope. Remember when Google only showed one ad in search results?
“Slippery slope” is a perfect term. But I wanted to add something here. In my experience, in the realm of UI, there is no middle notch. I’ve seen it time and time again… the moment you open the door to One, Infinity starts exerting its pull:
adding just one setting will send a message that We Do Settings Now and more settings will follow,
one uncomfortable exception followed by weeks of deliberations will inevitably open the door to subsequent mindless exceptions,
one cheap or lazy approach can spread through the interface like rust, subconsciously telling people “cheap and lazy solutions are okay here.”
Here are two examples I’ve been thinking about recently:
This right click menu in Chrome started with just one fork (new window or new tab) – now there are three alts that I have to choose between, every single time, even if I only ever use one option:
This – screenshotting in iOS – was originally just one fork: Save or Delete. Now it’s a staggering five options I have to choose from, every time, even if I never touch four of them:
Once you wedge one thing in the door, it’s really hard to stop. My theory is that this is because digital interfaces are pretty much all infinitely extensible. There will always be a way to add one more button, one more link, one more setting, one more ad. If something doesn’t fit, you make it smaller. If making it smaller looks bad, you add a scrollbar. If a scrollbar doesn’t feel right, there’s always overflow.
Not only is it very hard to create interfaces that have limitations, but a bad decision is not just precedent – it’s code that can be copied and reused. Existing code always had tons of… well, gravity, even before LLMs.
And so, products grow complex without anyone intending them to; a new team adds just one more thing, which in isolation always feels like nothing to worry about. The Hick’s Law, the extra mental load, the weirdness all grow in between those moments, in a no-man’s land no team typically feels responsible for. The logic is always circular: Why would the team adding a third option have to do something a team adding a second option didn’t have to do? Why would the team adding the second option worry in advance about option number 5?
This is why it’s important to hire and recognize people who will understand that those limitations have to be imposed arbitrarily, and empower them to be able to say, “Let‘s not add this. We like our own stickers better.”
My MacBook does have a sticker, which I bought and put on it since for some reason I find it really funny.
An interesting short story from Ernie Smith at Tedium, who ventured out to do the opposite of what we usually cover on this blog – disrespect his motor memory:
Recently, I made a realization: I have been unwillingly addicted to Facebook for a long time, and it’s not even because I like Facebook. Rather, it’s because I find it an extremely easy URL to type into a modern web browser’s omnibar. This sounds crazy, but the first two letters, f and a, are on the home row, and I don’t really rely on bookmarks, but my browser’s history function to type in URLs.
This creates a sort of recency bias. If I type in the same URL a lot, it’s the one that pops up the most. And so, if I’m at a browser with no clear idea of what my intent for the next page I load up, I inevitably type in “fa,” which would suck me in. […]
So, what I ended up doing was creating a URL that does nothing but forward to Google News. […] The result is that whenever I type in my new Facebook URL, I go to a news aggregator, which is inevitably what I was using Facebook for anyway. A week later, and my Facebook usage has gone down considerably.
There is something really interesting about creating your own URL for a purpose like this. Smith doesn’t disclose his, but you can imagine it’s something like facebook.aresluna.org that just redirects to a news aggregator. If creating a new URL is too difficult, there are always other options:
This is a good example of some of the challenges with “recent” interfaces I am such a big fan of. If you’re designing recents and you think they can turn against the user or otherwise get in their way, it’s good to offer not just a “clear recents” feature that gets rid of them all, like here in Apple’s Music…
…but also individual clears, like here in Bluesky:
I don’t know if this is true for all the browsers, but in Chrome and Safari, you can also clear individual suggestions this way:
Smith writes a bit more about the addictive nature of computers, but I’ll let you read on your own.
Nice moment in Slack and Medium – when logging in, the login code that arrives via email is already there in the subject, in addition to hiding inside:
This feels good for two reasons. One is the obvious one: you see the code earlier, it might show up in a notification, etc.
But also, this should prevent multiple login codes to be threaded as a “conversation” inside your email client, since threading is based on the email subject – and threaded utility emails can be extra confusing.
Over the years, I acquired this weird collection of almost-invisible, but important signifiers of when I know a product really focuses on craft and thinks about its users.
I thought about one recently. Here’s what happens when you try to copy a long block of text from YouTube’s (otherwise very useful) text transcript pane:
And here’s an analogous example from GitHub:
GitHub’s arrives ready to go. YouTube’s throws in a lot of messy things in between the lines.
Why does it matter? Because these both feel like places you’ll be copying a lot from, and dealing with a messy paste can feel so, so unpleasant.
You have probably seen this chart before, from xkcd:
This is the fabled automation trade-off, or the high fixed cost vs. low variable cost dilemma.
Yeah, if you’re doing a lot of copy/paste, you might invest in creating some sort of a clean-up step, or even going through a programming text editor which has multiple cursors or other casual automation. But what if you don’t do that often, or if you don’t even know how much time it’d take you to automate it? Then the investment seems scary or insurmountable, and you’re stuck doing something like this, time and again:
And it’s really nice to encounter a place like GitHub, where the team was thoughtful enough to save you all this trouble.
There is also an asymmetry that’s worth pointing out. I believe making this good doesn’t have to be a lot of work for people putting these surfaces together. Here’s me fixing the YouTube situation with two simple lines of CSS with user-select: none:
I don’t know if it’d be as easy for all big text block situations, but I think it’s good practice to look around a bit and think about what are tiny things that you can do on your side that will save your users minutes or hours of tedium (see also: recents and paste and even more recents).
I still don’t use any AI code in my work, but I have to review more and more of it these days. One of the things bothering me about that these days is just how lacking in personality that code is.
RenderMan is a code base which is now over forty years old. It is a collection of idiosyncratic styles written by equally idiosyncratic people.
I’ve been in this code base for 26+ years and I can recognize the author of many chunks simply by looking at indentation, comments, or coding style. And I can often map style to personality quirks of the author.
Dan McCoy’s code for converting general polyhedra from 1990 still survives today. Probably one of the few pieces of code left that actually has a for ( ; l; l = l->next) loop for linked lists. Dan is also the only person I’ve ever seen use the abbreviation R.N.G in comments.
Tom Duff is the inventor of the Duff Device, so you can imagine what kind of code he might write. But he also left a comment in the implicit field code which was a quote from the Preface to Samuel Johnson’s Dictionary, from 1755. That’s just who he is.
(In a fit of hubris, many years later when I refactored the code, I left an answering comment which was a quote from the Preface to Noah Webster’s “An American Dictionary of the English Language. I’m not sure Tom ever noticed this.)
I could go on and on about all of our recognizable quirks, but living in a code base with that history is like living in a Berkeley Craftsman home. It’s old, it’s creaky, okay, it’s missing AC and you’re probably going to die when it hits 100 in the summer (which happens all too often these days), but dammit, it’s charming and it’s artsy. […]
[With Claude-generated code] there’s no typo or quirk that immediately recalls an interesting whiteboard discussion in the author’s office. It’s just code and comments repeating what the code does.
Code is art. I work at a studio full of ungodly talented artists, but I will still die on this hill. Code is often messy and dirty and it’s a pain to create and get right but the results reflect the personality of the creator and the pain of the creation. Just like the rest of art. Sometimes you have to look at the source code to see that, but it’s there if you look for it, hidden beneath the surface.
In the era of the telegraph, a century ago, you could listen to the dits and the dahs and decode the literal message, but you could also pay attention to the rhythm and the timing and the quirks of someone’s particular finger on someone’s particular Morse key – and learn to recognize not just a particular person, but also, sometimes, even their mood. There are stories of Allied spies knowing exactly which of the German operators they surveilled (but never met in person) was sending messages at a given moment, just by learning their tapping style, known as “fist.”
I found it delightful to read Fong’s stories of his coworker programming fists.
In early 2023, Dan Olson at Folding Ideas made a scathing, smart, almost two-hour-long video essay about Decentraland, the metaverse that was one of the poster children of the web3 era:
Most of what Decentraland does, and what it fails to do, are things that would be considered forgivable or quaint in a Kickstarter MMO that had clearly bitten off more than the creators could ever chew, but given that this is a project founded on cryptocurrency, all of those foibles are laced with the language of finance and landlordism. Strolling down Decentraland’s spacious boulevards at 5 frames per second rewards the user with a seemingly endless parade of virtual billboards brightly proclaiming that the space you see is all available to rent.
In May this year, Nick Heer at Pixel Envy wrote a copiously annotated birds-eye overview of Meta’s metaverse attempts thus far, in an essay called The Metaverse Fever Dream:
Officially, Meta is still all-in on the concept around which it pivoted the entire company in 2021. It still has a whole marketing page proclaiming its belief “in the future of connection in the metaverse”. You can go shop its lineup of Quest headsets which Meta says represent the best and most immersive metaverse experience, though its flagship model is now two-and-a-half years old. It has awkwardly promoted its Ray-Bans as “A.I. glasses” despite them becoming the company’s most successful line of mixed reality products, and it is desperately trying to connect its newest muse of A.I. with its last one. The single mention of “metaverse” on its Q1 2026 earnings call (PDF) is when Zuckerberg claimed to be “excited for more of our metaverse efforts to be powered by the A.I. models we’re training as well”.
I linked to Meta’s metaverse reviewsbefore, but I thought these two (very) deep dives are great to invest in, side by side. Both of the failed metaverses look similar only on the surface. They were spun by very different organizations, started with different goals and premises, and their creative and maybe even ethical bankruptcies have a very different dimensionality.
In the context of this blog, it’s also interesting to reflect on how poorly they’re both made, which is extra fascinating given the disparity of budgets of the efforts. My guess would be something like this:
Mark Zuckerberg and Meta’s leadership do not understand design, so even though there might be a lot of talented designers at Meta, their efforts do not end up mattering as much.
Decentraland is ostensibly “open source” – or at least open-source-flavoured – and open source generally struggles with attracting talented designers.
These are two interesting and distinct failure modes – although, as the essays make abundantly clear, no amount of design talent, execution, or craft could turn successful an idea whose entire premise is a house of cards made out of newsprint-grade paper and magical thinking.
Here’s a nice moment in Logic Pro, a music app. Like with most such apps, you can press R to record playing an instrument. However, if you forgot to start recording, or were just goofing around and stumbled upon something wonderful, you can press ⇧R and the recording will appear anyway, as if you had a time machine. This is a quick TikTok video showing it in action:
The feature is called Flashback Capture. Of course, just as it was with undo send, this is no magic. The app is always recording the events quietly, and then offers you to make them “real” if you want.
I dug around and found a support document that offers a rare view into the mechanics of this feature, which are slightly more sophisticated than I imagined:
When playback is stopped, Flashback Capture creates a separate region containing all the MIDI events received since the last playback. However, after a pause of 20 seconds between incoming MIDI events, those initial MIDI events before the pause are discarded. If when playback is stopped, you perform some MIDI events and then pause for 1.5 bars or longer, those initial notes aren’t included in the visible part of your region. If you do want those MIDI events to be included in the created region, you can drag the left region boundary to expose them.
What it seems to say is:
If there is a longer pause within your play, the notes are still recovered, but hidden. You can always drag to reveal them, but in effect, only the most recent of your notes are immediately visible – a nice touch. (The moment you start dragging, it also shows you a quick preview of where you’re going, which is extra thoughtful!)
If the pause is 20 seconds or more, all the notes before that pause are no longer preserved – presumably to prevent too much wasted data in your file.
However, after you stop playing, you have infinite time to invoke Flashback Capture and recover the notes.
This seems like a good and thoughtful feature that prevents data loss, a sort of magical “reverse redo.”
Thank you to Chris Krycho for telling me about this feature, which is apparently also available in other music apps, e.g. Cubase and Dorico.
This is an image file, containing a picture of my cat. But if I rename it to .MP4, it becomes a video file – also of my cat. If rename to .PDF, it becomes a text document containing the script for this video. It can also be a valid webpage, a .ZIP archive, or a PowerPoint presentation, all by simply changing the name. This kind of file is sometimes called a “polyglot” (although, usually that term refers to code that works in multiple programming languages).
This kind of a file is not something that you will realistically need, but it’s a fun look into various approaches to headers and structures of file formats – something we don’t usually get to think about a lot.
Buried inside the video is also an interesting digression: is the file extension just a method of delivering the file to the right application? If I rename .jpeg to .gif, and both are routed to Pixelmator, should Pixelmator do its best to detect it’s a JPEG file under the hood, or fail with a “this doesn’t look like a GIF file” message?
The web has a similar challenge in the form of MIME sniffing – “MIME” is sort of the web’s equivalent of extensions, “sniffing” means detecting the file from its contents alone, ignoring everything else – and that had some security considerations, as it allowed bad actors to sneak in some malicious code under the guise of something more innocuous… basically what the video is doing for fun, but now weaponized.
This is all pretty technical for this blog, but inside the Wikipedia entry for MIME sniffing is this passage that caught my attention:
[MIME sniffing is still used by some browsers. However,] by making sites which do not correctly assign MIME types to content appear to work correctly in those browsers, it fails to encourage the correct labeling of material, which in turn makes content sniffing necessary for these sites to work, creating a vicious circle of incompatibility with web standards and security best practices.
Decades before MIME sniffing, Jon Postel captured the essence of that line of thinking by coining Postel’s Law – “be conservative in what you send, be liberal in what you accept” – but as enticing as it is, that has challenges similar to the above quote:
A flaw can become entrenched as a de facto standard. Any implementation of the protocol is required to replicate the aberrant behavior, or it is not interoperable. […] Ensuring interoperability in this environment is often referred to as aiming to be ”bug-for-bug compatible”.
While Postel’s Law was about data flowing in and out of computer systems, the premise is to me a more evergreen design question, applicable to so many other things. Feeling “liberal in what you accept” can feel helpful, but can teach users bad habits and have bigger consequences. For any project where this applies, it’s worth asking: should we go out of our way to help the user even if they mess up, or should we be more rigid and teach them to follow the rules more strictly, as it will benefit them in the future?
You can ask if they want to run the suggested command, but don’t force it on them. For example:
$ heroku pss
› Warning: pss is not a heroku command.
Did you mean ps? [y/n]:
Rather than suggesting the corrected syntax, you might be tempted to just run it for them, as if they’d typed it right in the first place. Sometimes this is the right thing to do, but not always.
Firstly, invalid input doesn’t necessarily imply a simple typo—it can often mean the user has made a logical mistake, or misused a shell variable. Assuming what they meant can be dangerous, especially if the resulting action modifies state.
Secondly, be aware that if you change what the user typed, they won’t learn the correct syntax. In effect, you’re ruling that the way they typed it is valid and correct, and you’re committing to supporting that indefinitely. Be intentional in making that decision, and document both syntaxes.
The transgression: Chrome took over a shortcut on my Mac – Ctrl+G – and it used it to throw me into Chrome’s version of Gemini that I have never used or was interested in using. Moreover, it decided it’s okay for Ctrl+G to put me there even if I pressed the shortcut outside of Chrome.
I was never asked by Chrome if it’s okay to do so. The way I found it installed it was in a very unpleasant way: I tried to use Ctrl+G in my coding editor to jump to a specific line, and I got this instead:
Stuff like that can make you feel like you lost your mind. I have no idea what this window is supposed to do, where did it come from, or even – initially – why it appeared. Note that it doesn’t even identify itself as either Chrome or Gemini, unless you read the scary caveat. It feels like the UI equivalent of breaking and entering.
Unsurprisingly, the pop-up doesn’t confess to stealing the shortcut, or allow you to toggle it off in any way:
It is possible to undo that behavior, but one has to connect it to Chrome first, and then go deep into its settings – first by clicking on “AI innovations,” and then by clicking on “Gemini in Chrome” – to find it:
Let’s not beat around the bush: This is effectively malware behaviour. It’s bullshit. It’s cancer. It’s deeply disrespectful toward the user. It’s prioritizing hollow metrics at the expense of everything else. But I don’t want this blog to chase news of the day or feed the outrage machine, so let me try to turn my anger into something useful.
We can start here: There are some global keyboard shortcuts that are genuinely good. A video call mute shortcut, screenshotting, “next slide” if you’re presenting in Zoom. Everything related to computer operation – volume, brightness, media transport controls – needs to be available regardless of focus or context. (In my keyboard customization essay, I introduced my own global keyboard shortcuts, for example for scanning the next page.)
But, an app installing a global keyboard shortcut without user consent is bad. This can never be anything other than opt-in. At the very least, Chrome should have shown me a clear UI that said “We’re thinking Ctrl+G would be fun for you to use. You okay with that?” and a button for me to press to confirm.
(Note: Ctrl+G is the shortcut for Macs. As far as I can tell, on Windows it is Alt+G.)
From people’s reactions, it seems this shortcut is auto-enabled for a subset of users – perhaps people who used Gemini before, or people on a plan that happens to include it. No matter how specific or small that group is, or how useful they might find the Ctrl+G pop-up, the issue remains: I have never consented to the app doing this.
I also partly blame macOS for ceding its responsibilities here. Mac’s keyboard customization features are a mess, and Mac doesn’t have a modern command repository. It’s not just that apps can register global shortcuts as they want, without the user knowing. It’s also that there is no shared inventory of them; if an app “swallows” a shortcut but does nothing noticeable with it, it can be really hard to figure out why a shortcut seemingly just stops working.
(Other apps that I remember having problems with “stealing” global shortcuts, and apps that a few readers posted are: 1Password, Notion, and Perplexity. I’d be curious if you have other examples!)
In light of macOS’s deficiencies, as an app, if you offer any shortcut customization – especially if you allow global shortcuts – I think it’s important to have a page that lists all of them shortcuts in one place. This is not what Chrome does, as various shortcut options are hidden on various pages in settings. Even Zoom, which is not generally known for having a great user interface, does better here:
And, since we’re back to Chrome, what a fall from grace! When Chrome started in the late 2000s, it felt like a browser that had user’s interest in mind, and protected people from ill-behaving websites. Today, it’s the operating system that needs to protect us from Chrome.
Also, don’t call a tab “AI innovations.” It’s tacky as hell. The market gets to decide what’s innovative and what is not.
A computer science professor Paul Cantrell, on Mastodon:
Creative work keeps taking roughly the same amount of human labor / attention / care, even as new technologies accelerate or remove things that used to take time.
This is because creativity is fundamentally not an efficiency problem; process is not just the means of producing output, but rather a labor vessel that holds the near-invisible work that is truly important.
One can feel the care that goes into creative work without being aware of that work, or even being aware that work of that type exists at all. This feeling is approximate, loose, vague, but cumulative and eventually all-important; work with no care behind it wears thin and tends to fade as people live with it over time.
I constantly see some people praise it not for what actually makes it good, but by taking the things it’s bad at and turning them into a puzzle to have “fun” solving.
I’ve had people tell me how “fun” it was to build a macro to handle some one-off text-refactoring problem. But when I looked at what they were doing and how long it took, my honest reaction was: I could have done that in Sublime in a minute with multiple cursors, or just written a quick script. […]
That’s what I mean by “invisible tools”. When you’re proficient with your editor of choice—whatever it is—it disappears into the background. But the moment it cannot handle something easily, it stops being invisible. What baffles me is that so many people treat that friction—the effort of working around a tool’s limitations—as the “fun” part, and then advertise it as evidence that the tool is great. […]
The text-editor-macro anecdote I mentioned is really about a gap between feeling productive versus being productive. There’s a sensation of cleverness that comes from solving a fiddly problem, and it’s easy to mistake that feeling for actual output. A tool that makes hard things feel heroic and clever feel like an achievement can register as “powerful” while quietly being slow. The honest test isn’t how engaged or clever you felt, it’s wall-clock time and how many mistakes you made getting there.
This I had more of a mixed reaction to.
I think it’s necessary to expect from tools to get out of the way, but there’s also nothing wrong with having fun with them.
My simple go-to example is this: When writing code, I sometimes use Find & Replace All, and am done within a few keystrokes. But sometimes, I press Find and then replace one at a time, jumping methodically through the file, and seeing each string in situ before changing it. I know the tool could do it all for me. I know I could be more efficient. But this intentional slowing down allows me to refamiliarize myself with the code, visit its forgotten nooks and crannies, and make sure I understand where and how the thing I’m changing is actually used.
The editor I use allows me to not be efficient when I choose not to be. In my work, flow operates at different speeds; a good tool understands that and doesn’t force me into a particular one.
I think ultimately indeed, the tool does need to disappear, and make you be in charge of whatever speed you want to operate at, and how much friction or difficulty you choose to face (do you bump the lamp or not?). But it’s not as simple as always “reducing wall-clock time and mistakes.” Like Cantrell says above: Creativity is fundamentally not an efficiency problem.
A typical use of Safari means two groups of sites: a regular set on the right, and “private” pages on the left (this is what Chrome calls “incognito mode”):
As expected, you can tap on either label, and switch to the relevant group with ease:
It also feels like you could slide it – and you can, except…
…you immediately encounter a Scroll Lock problem. You are not dragging the pill – you are dragging what’s underneath the pill. To switch, you have to go the other way:
You can immediately intuit some inherent unpleasant complexity of the whole system – not just in it “going the wrong way,” but also in how it creates room and then contracts it, in two separate steps, after you’re done.
The reason is that you can actually have more site groups than just the initial two. You can even drag to where the new site group would be, and create it this way:
I normally welcome these kinds of accelerators. But here, this feels overdesigned and confusing, as if someone drugged the tab instead of dragging it. The very same natural gesture – a left swipe – that should feel safe and send you to Private, will now put you in a scary new full-screen/keyboard-out flow you almost never need.
Why this relates to system design is that on/off toggles in iOS were recently redesigned to resemble oblong pills:
Those do respond to dragging as you’d expect:
Along the same lines, on the springboard pagination pill, dragging to the right means the next page:
And so now the system is schizophrenic and identical-looking design primitives mean the opposite things. It’s as if the computer itself kept randomly pressing Scroll Lock for you, preventing you from developing a solid understanding of the system first, and motor memory second.
I think the mistakes made here were twofold. First, the design overoptimized for two unnecessary things: people actually using site groups (not common), and ease of use in creating site groups (not important). My slightly cynical hypothesis is that this design presented really well in demos, which sometimes can derail a project. A more cynical theory is that this led to “accidental discoverability” that made the site group metrics look better.
Second, and more important part: This particular design received an exception that it didn’t deserve. No one noticed the systemic challenge of similar UI elements doing opposite things, or people who did were not effective in pushing back. The metrics for new feature discovery are easy; the metrics for user confusion or frustration do not usually exist.
This is how interaction systems slowly fall apart. As I mentioned in the first part, it is likely that Safari’s exception will now be treated as “blessed,” and start spreading further. Given enough time, more and more pills will go in whatever direction they want when dragged – and people will learn not to trust any of them.
I know the feature is actually called “tab groups” but I called it “site groups” intentionally, because otherwise it’s a tabbed control controlling tab groups, and things get confusing really quickly. Also, thank you to Martin Hoffman for initiating this post.
My favourite was Shakespeare, in which the whole program resembles a play. Believe it or not, but this code outputs “HI”:
A New Beginning.
Hamlet, a literary/storage device.
Juliet, an orator.
Act I: The Only Act.
Scene I: The Prince's Speech.
[Enter Hamlet and Juliet]
Juliet: Thou art the sum of an amazing healthy honest noble peaceful
fine Lord and a lovely sweet golden summer's day. Speak your
mind!
[A pause]
Juliet: Thou art the sum of thyself and a King. Speak your mind!
Thou art the sum of an amazing healthy honest hamster and a golden
chihuahua. Speak your mind!
[Exeunt]
It was interesting for me to see programming languages that intentionally remove some of the niceties and affordances we learned to take for granted. My guess is most of them are just art, or jokes, or a certain one-upmanship. But I couldn’t help but think of Arika Okrent’s excellent book In The Land Of Invented Languages. The book is about “human” languages like Esperanto and Klingon, but it’s much more interesting than I imagined, and maybe even quite a bit sadder: a story of people afflicted with a certain perfectionism who are not willing to accept languages simply cannot be perfect.
As a teenager I adored Norton Commander, learned some UI magic from early videogames, and dreamed of a Mac my family couldn’t afford. But I think the first product that taught me something truly memorable in terms of user experience was, of all things, Excel 97.
Excel 97 cooked. It was rendered in brand-new, gorgeous Tahoma, had keyboard underlines everywhere, and felt complete in terms of features. Sure, you could maybe sense the beginning of the bloat with the reorderable menus and the bolted-on Clippy, but Excel 97 felt tight and zippy even on an abominable computer put together on a high-schooler budget from used hardware pieces that were never meant to meet.
But what made me love Excel 97 was one specific thing: the Repeat command. You could invoke Repeat via Ctrl+Y, but my fingers learned to love its stranger alter ego, F4. This is what pressing F4 did:
It was a bit more clever than just replaying the previous action. If you changed the font and its size, it would repeat both:
And it didn’t only repeat formatting, but also some actions, like inserting new rows, or merging cells:
There are, of course, many other solutions to make these things less tedious:
make a complex selection first (if possible), and format later,
use styles instead of naked formatting,
copy/paste formatting only,
paint format from one cell to another,
record and repeat keystrokes,
save individual actions into bigger macros and reuse them.
…and some of them were even available in Excel 97.
But it was Repeat that stole my heart. I think this is because it was two types of magic combined: the magic of motor memory + the magic of smart software.
The first part meant that soon, it didn’t really feel I was pressing F4. The shortcut lodged itself in my fingers and in time, it became a gesture as natural as pressing Backspace or arrow keys. All the other alternatives above required thought or bureaucracy, but Repeat was mindless – I would occasionally watch my hand perform it on its own.
The second part is that F4 felt like it was reading my mind. There were no options; Repeat just always seemed to do the thing I expected from it. As I understood this kind of functionality more, years later, I learned to appreciate the deeper thinking necessary to make it work. Repeat wasn’t actually repeating keystrokes and commands – it was some tricky dance of adjectives pretending to be verbs, with groundwork necessary so that the system felt stable and consistent.
The feature wasn’t flashy. It didn’t even have a separate toolbar button. But it was beautiful.
Repeat is still there in Excel on my Mac today, in Google Sheets, and a few other apps like BBEdit. It’s often an extension of redo, although I prefer thinking of it as something independent. Some apps like Sublime Text or Keyboard Maestro have a quick record/repeat function that feels similar, although it’s not as smart – this one is solely repeating keystrokes, and requires you to start recording first. (Part of Repeat’s beauty is that it works retroactively.)
If you look at the keyboards on my desk, they all appear blank…
…with one exception:
Repeat was fantastic. I wanted it as a user elsewhere. Then, as a designer, I wanted it for my users.
In time, I learned to appreciate other things like it, but both the solitary legend on my keyboard, and the current favicon of Unsung, are an homage to the original, 1997’s Repeat. (Original to me, at least. Repeat existed in Office 95 too, and perhaps in some other apps before that.)
If I got to spend my entire professional life designing hard-to-make, invisible things that make other people feel powerful and awesome, it would be a life well spent.
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.
Bear (a notetaking tool) has simple image resizing, with one extra nicety – if your images are near each other, resizing one will snap to the width of the other:
In the Finder, columns snap to the width necessary to keep all the names untruncated – and not one pixel more:
(Sidebar: This is also the only place I’m mentioning today that nicely uses the trackpad’s haptic feedback at the snap moment. I tried to indicate it in the video; this is not the final visual treatment I’m thinking of, but let me know if this kind of visualization of haptics feels useful to you!)
macOS does something really interesting when you get its windows close to each other. Instead of typical snapping – pulling the thing you hold toward the other item like a magnet – it instead prevents you from going further for a while, in either direction. Perhaps the right analog here would be glue:
If initially feels a bit funny, but I think I like it. It’s less aggressive and avoids needing some sort of cancellation (an option or a modifier key) if you don’t want it, because it never feels in a way.
It also works for matching heights, like in Bear:
In Figma, building atop regular snapping, we introduced something I awkwardly called “self-snapping”: if your objects are inside a container, the container will snap its padding to whatever it sees on the other side, without any explicit auto layout/flexbox:
I am sharing these five examples (and one from before) because I think they exemplify a nice thing: precision without bureaucracy. In each case you could imagine an explicit heavy option somewhere in the menu…
Bear: Set Image Width…
macOS: Match Window Heights
Finder: Restore Column Width
Figma: Unify Padding
…that would feel slow and cumbersome.
Instead, these take the freedom of direct manipulation and sprinkle just enough almost-invisible structure in a moment where that structure is undeniably useful. (Of course, you still might want explicit options somewhere in the menu or your command palette, if only for accessibility reasons.)
I like that these quiet features have your back and make you look good, and that their creators understand that something almost aligned can feel worse than something completely misaligned.
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.
When you visit parts of the website of the Driver & Vehicle Licensing Agency in the U.K. outside of standard office hours, you will see this:
It seems ridiculous, almost like the famous 500-mile email bug, but Dafydd Vaughan explains how it came to be. It won’t be a surprise that the story starts with an old computer system, built around a day/night cadence where people would visit the agency during the day, the information would be collected, and all the data processing would happen overnight:
At the time, many of DVLA’s services – particularly those relating to driving licences were still backed by an old IBM mainframe from the 1980s – fondly known as Drivers-90 (or D90 for short). D90 was your typical mainframe – code written in COBOL using the ADABAS database package. Most data processing happened “offline” – through batch jobs which ran during an overnight window.
The team upgrading it in 2013 decided to not attack too many things at once, and swap the innards but keep the day/night system intact.
I’ll let you read some details inside if you are interested, and if you want to learn why the 2013 decision is still a 2026 (or at least 2025) reality. Like many of these, it is a story of heavy financial and technical constraints. But I will excerpt this bit, because I think many teams in any company – design systems, security, or “core” (whatever that happens to be) – would relate to it:
It’s difficult for an organisation to keep its focus and attention on a complex upgrade – particularly without getting noticeable benefits along the way.
The tricky part is that in many places you do end up in a legacy situation that is exactly as absurd as “an internet service having opening hours,” but you might be too close to the problem to even realize it.
Why log in when you have to, when you can instead experience the same Kafkaesque maze of pages, redirects, confirmation emails, copying codes, and searching for a second device—all a week in advance?
I agree with authentication experiences being absolutely horrible, especially in the corporate context. But I think the “your login expires in 5 days” callout is actually positive. Your reauthentication will happen anyway according to the security regimen. Instead of it potentially surprising you at a wrong moment – for example just before, or in themiddle of the presentation in front of a boss – you could get ahead on that process during the next moment of downtime, and have some peace of mind.
I know Slack has a similar warning, although I don’t happen to have a screenshot handy; I imagine a few other places do, too.
(However, that gesture doesn’t give apps permission to handle expiring credentials badly. There should be no excuse for losing anything the user is doing – for example writing a long comment – just because the reauthentication kicks in in the middle of them doing that. Even the app losing its mind for a while just as its separate parts are waking up to the reality of reauthentication at their own pace and throwing strange errors, but the login screen hasn’t reappeared yet, can be really confusing.)
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.
Joanna Stern explains why this emoji is correct today: 📅. (This one too: 📆)
I thought the two different calendars was some trickery, but the answer is simpler than that. I did not realize that, inexplicably, there are two distinct calendar emoji: one for calendar, and one for a tear-off calendar.
The way I learned about it was to use a tool I made a few years ago called text.makeup:
I thought this would be a nice opportunity to share it with you. If you’re debugging a string you don’t understand, or are just interested in learning about various Unicode or encoding secrets through playing (see the left sidebar!), it might be a fun thing to use.
On Mastodon, Alex Russell, a product architect who’s worked on Chrome and Edge, and has focused on tech standards for a while:
Once Upon A Time At Google, a team presented results that had confounded them: making the system load several times faster increased engagement somewhat, but in line with Tammy’s findings, engagement went way up for every 100ms improvement below the 1s threshold.
Going fast enough to become “dial tone” changed user behaviour and expectations in a hugely positive way for the product.
This sort of “no such thing as too fast until you prove it” lesson is everywhere.
Phrasing it as “no such thing as too fast” is really interesting, and not something I encountered before.
(The way I understand the “dial tone” remark is commenting on reliability of landline phones in the second half of last century. The landlines were extremely reliable and even came with their own power source; you could pick up the handset and the dial tone – the system’s confirmation it’s ready for you to dial – was inevitably and immediately always there, already waiting for you. There was never any delay when the phone had to get ready for you to call.)
If you make websites for a living, stop what you’re doing and read this research by Tammy Everts; it shows what many of us have been saying for a long time: even if there is such a thing as “fast enough” (there isn’t), it’s generally much faster than you are targeting.
The report itself is perhaps too deep and jargony for this blog, but the TL; DR seems to be: Google suggests the time for the site to finish loading its largest piece is 2.5 seconds, and Everts argues and shows evidence that it’s a lot less.
I have before focused on “finger speed” – making sure the interactions operate at the “speed of flow,” which requires sweating speeds counted in milliseconds. Everts’s and Russell’s comments confirm that millisecond-speeds matter for other reasons, too.
Thank you to everyone who answered the call for good software updates from last week. I received so many nominations that the list below is severely narrowed down, but I appreciated every response!
I grouped the answers in sections I saw emerge organically, I included links to apps, and did some light editing for clarity. (You can always explore more answers on Mastodon and Bluesky.)
I hope you find this inspiring in some way – I know I did! – or at least enjoyable.
Something I asked for
People shared examples of improvements they particularly asked for, improvements that meant something for people close to them, or even simply seeing people given credit for ideas:
I’m a space educator and bring a mobile planetarium in schools. I use a piece of open source software called Gaia Sky. It is developed by only one developer, and I seem to be one of only a handful of people in the issue queue requesting updates. Always a prompt and incredible reply from the developer.
I filed a request: “In my shows, I tell the audience that the rings of Saturn are made of bits of ice, rock, and dust. Then when I fly through, it shows a mostly 2D ring system. Has [making the rings use particles instead] been considered before?” I made the issue on February 12, and by May 11 had a Saturn ring system with thousands of little rocks and pebbles running smoothly in my planetarium dome. Kids loved it.
Earlier this year I contacted Fantastical’s Flexibits requesting that hiding an event was accessible through the menu bar, not only in the contextual menu. Few weeks later, they emailed me to let me know the feature was coming in the following release.
The dev behind OpenStreet Browser listened to my feedback and added a filter item to a more logical category.
The recent SailfishOS update brought back the weather app and implemented Bluetooth for the Android support. Both of those are things my dad asked for, so I was quite happy! :)
The [social network] Pachli developer is amazing, the care he puts on everything, and mentioning every people that was involved on new ideas/fixes/improvements/translations... I do not remember others doing it. It’s great.
Every Pachli update is a prove of something great happened/is happening... Increases the hope world count a little.
I enjoyed using Easy CSV Editor and JSON Editor by VDT Labs in 2020-ish. Unfortunately, JSON Editor was macOS-only at the time while Easy CSV Editor was also available on iOS. So I contacted the guy behind VDT Labs, and asked whether he planned publishing an iOS version of JSON Editor anytime soon.
He got back to me immediately, said he didn’t have any plans, but liked the idea. He asked for my opinion on a few decisions he’d have to make, then published an iOS app literally weeks later. I love using his software. […] When you published I trust in TextEdit, his stuff came to mind immediately despite getting the occasional feature here and there. It’s nothing flashy, but the apps are simply reliable and haven’t changed much at all.
Apps that are updated respectfully, without changing too many things
On that last note…
The last AntennaPod UI update looked great, but didn’t force me to re-learn how it works. It has remained stable from a UX standpoint for as long as I have been using it.
I use the Infuse app primarily on the Apple TV (but also on the Mac and iPad occasionally) and I’m constantly impressed at their singular commitment to deliver on making their app useful for its users in all sorts of small thoughtful ways on an ongoing basis. Most recently it was supporting Plex and Jellyfin-style folder/file naming conventions for movie extras.
The only upgrade that always pleases me is a major Debian release. actually I’m happy because it’s been a rock for more than 20 years for me. I hate how everything is perpetually changing in IT nowadays. Debian doesn’t. The only change I fondly remember is when zfs integration got easier.
Updates that showed developers cared about more groups of people than just mainstream
Pachli’s update to include pronouns of the posters in the timestream.
OCR on macOC and iOS expanded into Swedish a while back. Super useful, especially on OS level, so all apps can use it.
Not sure what version, but the recent macOS that added made-for iPhone hearing aid support made a huge difference in my work life.
TL; DR: Apple established a standard for “made for iPhone” hearing aids that pair directly to iPhones quite a few years ago, but it’s only recently (in the post M1 era) where Macs have supported the same protocol. It means that calls and other audio from my work Mac go directly to my aids, without needing a clunky intermediary device worn around the neck. Since I need to wear the aids anyway, it means seamless access to audio. It’s just such a nice quality of life improvement.
An update that made an app better for me was the recent addition of flood warnings to Watch Duty. I have a mountain cabin in California but my main home is now in coastal North Carolina. I installed, and pay for, Watch Duty for warnings on California fires, but I can now also use it for warnings about North Carolina flooding, which can happen during tropical storms.
Updates that felt genuinely focused on helping users
The grocery list/recipe keeper/meal planner app AnyList. They just added “leftovers” tags and recipe queues to a recent update and my wife’s over the moon. It meshes perfectly with how her brain operates.
It has not been made fully public, but I am playing with the preview release of [font editor] Glyphs. And it’s great: Huge number of small fixes all around, but the whole UI has been revamped to match the macOS latest. Running variable fonts for testing is so much easier with an axes slider. Lots of editing tweaks that make things much easier. Genuinely nice and useful stuff, they pay attention and listen.
Every upgrade to Halide has made me happy. I can’t think of a specific change but every upgrade seems like it does better what a camera app should do: have stuff where your finger needs to go without thinking about it. Anything that helps my finger hit the right place at the right moment without thinking it’s a win. I think a camera app is the ultimate example of cognitive load mattering.
I’ve been building different things with [web framework] Web Origami and the most recent 0.7.0 beta release allowed me to do a lot of things I couldn’t before.
The creator is an absolute pleasure to work with. He listens to folks using the tool. Every update is gold and makes meaningful improvements based on how people are actually using it.
[Window manager] Niri consistently has extremely well thought and well implemented out features. Many of them are things that I hadn’t even considered wanting from a window manager that I now can’t live without.
Every update I have ever received for the Android application Kanji Study has been delightful. Chase Colburn does a great job with steadily improving the app and adding great new features. There are a bunch of little UI flourishes in it that I think you’d like. The kind of thing that comes from a tight loop between developer and users, smoothing off the edges that provide friction.
Something that comes to mind is the way it implements history. If I clicked on one of the characters in the Kanji listing for 美人, it would take me to the page for that kanji, and it’s easy to end up down a short rabbit hole if you’re the kind of person who enjoys leafing through a dictionary semi-randomly. But there’s a good history functionality that makes it a breeze to get back, and you can jump to an arbitrary point in that history instead of mashing “back” until you get to where you want to be. That’s not award-winning design, but it’s good design.
Updates to core stuff that never asks for limelight
Flighty: I don’t think I’ve seen a team work so hard to get the core use of their app nailed perfectly. No enshittification, no horrific UI changes. Their most recent update just further enhances what they’re great at.
[Painting app] Krita’s latest version has on screen text editing and it’s a very welcome addition to an already great tool!
I don’t know how recent it was, but the one for macOS where you can cut and paste text from images was a real pleasure to encounter.
When [3D modeler] FreeCad hit 1.0 – lots of small improvements in the sketching workbench made an area of the app you spend lots of time in so much nicer.
I’m thinking of the Transit trip planning app, which I love! There’s a bug fix for a problem where you would be en route, then looking at a different app on your phone, then come back to find out that the Transit had been killed in the background, and you had to restart your trip planning. That was a definite problem and i’m excited to hear that it’s been fixed!
I was also reading about the big design update they put out last year, which i continue to enjoy and get a lot of use out of. :)
[Text editor] Zed once had “improved font rendering on Linux” in the release notes and the text really looked better after the update.
I really want to share the Fantastical Calendar Mirroring feature. I have happily paid for Fantastical for years. And over that time I have paid for some calendar mirroring tools, none of which I liked for the money. Now I get a streamlined mirroring feature in the app I already love. It was a total surprise too!
I have used Fantastical for years now and, when I had to switch to using a Windows desktop at work last spring, I downloaded the released-but-still-under-development Fantastical for Windows app. I was accustomed to changing the visible calendar group on macOS using Ctrl+1 and would often try it out of habit, even though it wasn’t implemented on the Windows version yet. In fact, I would even mentally convert the macOS Ctrl+1 command to Windows-speak and type Alt+1. Then one day earlier this year, Alt+1 actually changed my calendar group. Much to my surprise, I had again typed the shortcut, despite it doing absolutely nothing many times before, and found that Flexibits had not only added a keyboard shortcut for that setting, they had added the keyboard shortcut I knew to expect coming from macOS.
When did iOS add document scanning with OCR? iOS 17? 18? Much better to use a phone instead of a dedicated scanner for periodic receipt scanning, plus the document then syncs to a Mac.
[Text editor] BBEdit 16 has some nice quality-of-life improvements, like per-project colour settings, which might help me to avoid accidentally making changes to the wrong version of a project, something I’ve done more than once.
This is a sad, sad commentary on my life choices in general, but i happen to be really glad that a recent Outlook for Mac update gained the ability to import PST files. [Legal software] eDiscovery still exports in PST format, so until this feature launched you had another step (or more, depending on your method) in getting exported mail back into a mailbox that lives on a Mac.
App makers working hard on developing trust in ongoing updates
The Playdate game console. They do such a great job adding joy and functionality to the platform with each software update. I continue to love the music and thoughtful interactions throughout, but more specifically the recent-ish update they added to the game browser, adding in folders and improving access to games on the system.
Cities: Skylines II has been on an incredible upward trajectory ever since Paradox gave the game to Iceflake. Optimization, features, just overall feel of the game have all improved since they took over at the start of the year. It’s a great redemption arc for a game that many people want to be great, but fell short in its first few years.
[RSS reader] NetNewsWire: every update does something genuinely useful like action log in one of the latest updates, so I can see what’s the problem if feed update takes suspiciously long time.
Wrike Desktop for Windows: very much a rolling release model, they do a monthly update, and I’m just happy when my work applications don’t break or get a bunch of BS added that I didn’t need (just didn’t want to use enshittification twice in one email). The most recent update was minor, some field admin changes and some further detailed reporting. Can’t beat that.
The release notes I’m always excited for are Zen Browser. They’ve been cranking through a roadmap of user-focused features, and their design is opinionated about it. Not always right, mind, but with strong convictions. Recently, improvements around tab tiling and the addition of “boosts” – color scheme and element zapping without an extension.
Stripe continually improves. it’s the SaaS vendor I use and am most pleased by. Every few months they add a new feature and I usually react “ah, that’s good” and “wow, their documentation is so good I can decide if I want to implement this and implementation will be so easy”
The team at [map software] QGIS consistently makes the app better with each release. Over the years I’ve made my peace with a dorky OSS interface and I appreciate that this isn’t being continually reinvented. Meanwhile, they’re keeping up with all the changes and movements in geospatial tech and ensuring that updates to key packages make their way in.
Let’s hear it for game devs who do free content+QoL updates for years after release. No Man’s Sky is the poster child here, but I’m constantly amazed by the number of indies who substantially add to the game experience long after they’ve been paid. (And yes, I know this helps sell the game + DLCs). I think Criterion’s Burnout Paradise was the first to really surprise me this way. IIRC they didn’t add much content for free (maybe a couple of game modes?), but they overhauled the UI completely.
Yeah, Pachli and [browser] Vivaldi came to my mind too. These are the ones that I’m not afraid to update, and while they were great already, somehow they are still getting better and better.
the Typeface app for MacOS continues to be a spark of joy for me. Recent updates have added a nice font pairings tool and thoughtful UI updates. I always look forward to new updates from this dev.
[Personal finance app] YNAB! This one has been the most consistent over the past few years for me. It feels like every single update just made it so much better. They added a summary home screen, removed some fluff, and added even more reflection features which is really convenient for a budget app.
App makers that feel like they’re going against the current bad trends
For me, every [photo gallery] Ente update so far was a significant improvement and going in the direction I’d like things to go. Recently, I was positively surprised by the new offline gallery feature to use Ente without account from March this year – refreshingly different from where most projects are heading.
NetNewsWire 7 required macOS Tahoe when it came out, but was in a later update made compatible with previous macOS, Sequoia.
[Personal database] Obsidian — one change that was fun.
The folks at FernCRM made their platform AI-optional. They basically will turn off all the AI features if you don’t want them. And for the folks who use those features a tiny bit, they offer selective metering so you don’t have to pay for everything if you don’t use everything.
I literally canceled a premium subscription to a software I liked because it was mandatory and weirdly intrusive. People appreciate choices!
Pretty much any [social network server] GoToSocial update falls into that category for me. [Software framework] Forgejo updates do as well.
I found that projects with a strong anti-AI policy generally deliver delightful updates. I wonder if there’s a correlation. (I really don’t, there is.)
The excellent [podcast app] Pocket Casts just launched generated chapters in podcasts. They’re automatically added with (whisper it) AI, but that doesn’t matter. They just work and are surprisingly useful and delightful to use. This isn’t an “AI feature” - it’s a feature that just happens to have been made possible because of AI.
I find myself looking at the chapters of almost every podcast I listen to now as a sort of preview and taster and navigation menu. Helps me decide if I want to commit to the whole episode or just skip to a particular section. Wonderful stuff. I didn’t realise it would be such a valuable addition until it was added and I started using it. I’ve attached a screenshot from a recent episode of Blair Braverman’s brilliant What To Carry, What To Burn pod (which I can also recommend).
Updates that are presented well and fun to explore
We chatted about good release notes before, and here are some more good updates – ones designed that exude some amount of healthy pride, and ones that people simply enjoy reading.
The first thing that makes me happy is how pretty the notes look. They’re not a boring list of changes.
Soulver 4’s release notes were great: an overview of the new features followed by examples / documentation of how to use them.
I also enjoy reading This Week in Plasma for [Linux distribution] KDE, even if I don’t use it much and it’s not release notes strictly speaking, but the fact they explain what and why they did is so cool.
Apps that don’t pressure people to update
The most delightful part of the [calculator app] Soulver update is that they’re still doing major paid versions (not subscription).
Soulver 2 and 3 never stopped working. (I never got to use Soulver 1, so can’t speak to that.) In fact, the email that announced v4 said: “Please note, there’s no pressure to upgrade if you’re happy staying with Soulver 3, which you can continue to download from here.”
Ever since I started using Blender a few years back, every update has been solid, well documented, and focused on improvements to real things its users care about. Whenever I check the release notes it’s like: “new geometry nodes! more cycles renderer optimizations! more compositor features!” Even if this post jinxes it and the next release has all kinds of AI garbage grafted onto it, it will also never force me to update.
Particular updates that stuck in my memory
I really liked this section:
You asked for recent, but about 30 years ago I got a BIOS upgrade which fixed a bug in the HD driver and made it quicker. That was sweet.
I was just thinking the other day about how the MKII version of Roland’s MC-500 sequencer software is still one of the most joyous software updates I can ever recall. This was in like 1987 or something.
The details are somewhat lost in the mists of time but I just remember getting a whole boatload of new functionality, some of which I didn’t even know I needed, and yet it all fitted perfectly within the conventions established by v1 so there was nothing new to learn in terms of the UI. Amazing stuff for what was essentially a numerical keypad and a few function keys.
The MkII software came out when they released MkII hardware – but was completely compatible with my MkI. That was the big joy about it, getting all the great new features without having to obsolete/upgrade my hardware. (I think it even came with a sticker to put over the logo.) Can you imagine that?!
I hope you’ll forgive me breaking the rules a little bit, but one of my favourites ever was Super Mario Brothers 3.
Let’s pretend as we all should that Super Mario Brothers 2 never existed and look at SMB3 as a sequel that fixed so many things from SMB:
You could now go backwards in a level in case you missed something
You could replay a level you’ve already cleared to explore and find new things
You had a place to put power-ups for later
You could freaking fly
Perhaps that’s the dream – to release an update so good that the users think about forever.
In this 7-minute video, kaptainkristian talks about the fascinating process of making Who Framed Roger Rabbit, the pre-CGI hybrid animation/live action movie from 1988:
This is called “bumping the lamp” – a phrase coined by Disney during the production of Roger Rabbit to describe going above and beyond what was expected of the animators.
It would’ve been perfectly feasible if Roger stayed flatly illuminated throughout this scene like a cartoon normally would, but instead the animators put in the time to shade every cell uniquely so that the practical light would bounce off from the same way it would a physical object.
And they had to account for that dynamically shifting lighting with every contour in Roger’s limbs, his clothes, his face, the cast shadow he creates on the environment as well as the texture of the light, the slightest difference in color temperatures, the lamp sways… even Roger’s ears have a slight translucency, since they’re much thinner than the rest of his body. They thought of that.
Audiences had no expectation for this level of realism in 1988, but all these seemingly-superfluous details help sell the effect at a subconscious level.
“Bumping the lamp” can be seen on two interlocking levels: one that focuses on the quality of the output (as above), and one that focuses on process toward personal mastery of craft.
On that second level, here’s an anecdote from the original Mac team, a few years earlier:
One day Burrell started doing something radical. Andy came by my cube and said “You’ve got to come see what Burrell’s doing with Defender.” “How can you innovate with a video game?” I wondered. I’d seen Burrell and Andy innovate on all kinds of things, but I couldn’t image how he could somehow step outside the box of a video game - the machine controlled the flow and dictated the goals. How could you gain some control in that environment?
We started up a new competition, and when Burrell’s turn came up, he did something that stunned me. He immediately shot all his humans! This was completely against the goal of the game! He didn’t even go after the aliens, and when he shot the last human, they all turned to mutants and attacked him from all sides. He glanced in my direction with a grin on his face and said “Make a mess, clean it up!” and proceeded to dodge the swarm of angry mutants noisily chasing after him.
I am neither a good visual/motion person, nor a great gamer. But I recognize this desire to once in a while walk up to a pool and throw yourself into a deep end of it, out of principle. Sometimes when I start a new project, I choose a different framework or method I haven’t used before, just so things are harder. On Aresluna and here on Unsung, I very deliberately chose “no centering” as an arbitrary principle, just to push myself to embrace the – harder, but more rewarding – asymmetry, and see where that takes me.
I am sharing this just after I shared the other maxim because I believe in those more that I believe in style guides or design principles coming “from above.” I see craft blossom when it can flow from individuals, and when the organization and attendant processes recognize that. Let people bump the lamp, make a mess, feel certain way about weird things, and do other things – and then let others observe, learn from that, and share the strange rituals and arbitrary rules that make them try harder when no one’s asking for that.
Thanks to Jon Wiley for sharing the original video.
If you want to record the screen from your iPhone on your Mac, open the QuickTime Player app but ignore New Screen Recording, and click on New Movie Recording instead.
This instruction is a fever dream of three weird things in sequence:
What on earth is “QuickTime”?
I am recording with a player?
Why can’t I choose the option that describes exactly what I want to do?
It’s interesting to me to think how we got here:
QuickTime is a 1990s brand, an offshoot of QuickDraw. Instead of QuickAnimate or QuickPlay, Apple called it QuickTime because it felt cute: time is what separates static images from video. The branding was much more prominent in the 1990s and 2000s, but mostly fell out of use – searching for “quicktime” in system settings today, for example, yields zero results.
Long ago, the Player was the only free, consumer-facing part of QuickTime, so it needed special branding. You could purchase QuickTime Pro – you would even get aggressive ad banners for it inside Mac OS! – and its encoding and saving capabilities would then be sprinkled across the entire system.
“New Movie Recording” originally offered recording from external video cameras (like iSight, another cute name). “New Screen Recording” was added later, for recording from internal screens. My guess is that technically, architecturally, or both, it was easier to treat external screens (like iPhone or Apple TV) as external video cameras since the UI and affordances matched them more closely. So that’s why screen recording from external devices ended up under “New Movie Recording.”
As a UX historian, this is fun and fascinating! I love tracing back that kind of stuff and learning how certain strange things came to be.
As a user… not so much.
“If you want to record the screen from your iPhone on your Mac, open the QuickTime Player app but ignore New Screen Recording, and click on New Movie Recording instead.”
This feels thrice arbitrary, closer to a magical incantation than a computer command, requiring you to hold a bunch of counterintuitive things in your head, or look them up every time. “Wait, what was the strange name?“ “Yeah, it’s called a player, but that’s ok.” “Hmm, I remember something about not choosing the obvious command.“
I have this internal rule that a flow or a space in the UI should have at most one weird thing. I can’t prove it to you mathematically, and I would be the first to find exceptions to my own rule. But one weird thing makes me nervous, and two or more weird things in concert raise the hair at the back of my neck. Two weird things is when the “launch blocking” bulb lights up in my head. Work needs to happen to bring the weirdness count back to 1 or 0.
This is one example of what I dragged Apple earlier for: it’s not just speed that matters. It’s noticing this kind of complexity, places where an easy way was chosen, design debt accumulated, and things got simply too weird. Apple allowed three weird things to accumulate here.
(By the way, delightfulweird doesn’t count! But it’s hard for me to imagine anyone defending these three things above as delightful or positive in any way.)
“If you want to record the screen from your iPhone on your Mac, open the QuickTime Player app but ignore New Screen Recording, and click on New Movie Recording instead.”
“If you want to record the screen from your iPhone on your Mac, open the Recorder app and click on New Screen Recording.”
It’s not trivial to get to this or something similar, but it’s also not really hard. You can get rid of weird things, but you need to want it.
This was made by… someone, a while back, I believe in response to the Twitter logo redesign of 2012, which showed the new logomark as composed of exclusively circles:
It’s just… design can be so pretentious and up its own golden-ratioed ass, and I can’t help but love anything piercing that bubble. (In my perfect, naïve world, Doug Bowman – the designer behind the logo – also finds the joke hilarious!)
Also, I feel like design is just not… funny, all that often. Quick, think of any product design joke.
See what I mean?
I can’t, either. My favourite graphic design joke is “if it’s big and ugly, it’s not big enough.” (You know, it’s funny because it’s sad.)
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.
Favorite and least favorite file formats? I’ll start.
Favorite: TXT
Least favorite: HEIC
The answers – both replies and quote posts – are really interesting because most of the time they’re not about inherent capabilities of each format, but:
how well supported it is in the general ecosystem?
how painful it was last time I used it?
who’s using it and for what?
if there is one app I use it with, do I like this app? (interesting in the context of PDFs which some people love, and others hate)
Of course, Walsh put a finger on the scale with her initial example, but HEIC stands out as a favorite least favorite. I understand this is mostly out of its limited support, raising a question whether Apple spent the right amount of time socializing and incentivizing its adoption – even on a Mac, you can’t escape blank stares the moment you drag it into many websites/web apps:
HEIC on the other hand, Apple’s way of making photos smaller and everything else more complicated than it needs to be.
By the way HEIC is when you drag a picture from your Notes app into your email, and then it laughs in your face and is like sorry, girl, I’m HEIC!! I don’t do things like that!!
I didn’t know I had a least favorite file format but yeah HEIC can fuck right off
Sweet fucking hell fuck heic into the sun
Reading the replies here makes me feel like I live in an oddly privileged bubble in an inverse of the usual meaning of privilege for being a poor Android-using mfer who has never seen a HEIC in their life and had to actually look that sh*t up.
Least favorite is a toss up between HEIC (WHICH NOBODY ASKED FOR, APPLE) and WEBP
Controversial but I hope everyone involved with HEIC only tastes soap instead of cilantro forever
I agree with this person that WebP is much better supported than it used to, but it sometimes takes one link in the chain – cough Google Docs cough – for you to avoid a format forever. And, those are always lagging indicators. If a format didn’t work once in an important flow, it might take many years before you come back:
all the people saying “webp” in the quotes might as well be fighting WW2 still. look for another grievance. please
Some other fun answers:
IF IT’S CALLED [C]OMMA [S]EPARATED [V]ALUES WHY DO I HAVE TO OPEN A WINDOW AND CHANGE THE DEFAULT DELIMITER OPTION FROM TAB TO COMMA ??!?!?!
Favorite: MP3 (invented piracy, patents all expired, doesn’t need an FPU)
Least favorite: DICOM (nightmarish metadata, too many possible image encodings, when it wants a 3D volume the solution is just “a bunch of files in a folder”, also IT IS A NETWORK PROTOCOL >:( )
Least fave: .R01, .R02, etc... – nothing needs to be split into multiple rar files! Please stop! The world has moved beyond this.
Least favorite: can I count those awful pointer doc types Google uses, like .gdoc and .gsheet
favorite: transparent PNG
least favorite: transparent PNG that is not really transparent but just a fuckin checkered background
I forgot about this meme:
For least fav I voted for GIF, having not only spent countless hours trying to make good-looking animated gifs that do not weigh tens of megabytes, look horrible, and cause performance issues… but also having worked on two different products (Medium and Figma) that had to swallow gifs made by others, and seeing engineers lose their minds peeking into their insides and how messy they were.
To be fair, GIF comes from the late 1980s, and simply outlived its purpose. It’s a fascinating format that literally deserves a book written about it: the messy patent wars, the pronunciation, the technical format and many surprises hiding inside, even the word “gifs” transcending the format itself to mean “short animated memes.”
To go back to the thread, a small pattern that I also encountered from time to time:
Least favorite: .md, specifically when it’s used for Sega Genesis game roms. There’s already a type of text file type called .md, so Windows tries to open them in notepad. Just call it .gen instead, nerd.
Favorite: TS, the one that opens in my IDE
Least Favorite: TS, the one that opens in Quicktime
I’m endlessly confounded (as a user) and fascinated (as a designer) when it comes the shortcut conventions in Google’s professional web apps.
They seem… bad, but bad in a strange, inexplicable, enthralling way. Previously, we encountered this:
The lessons there were, primarily: don’t… do this, and also maybe don’t show it like this.
Today’s entrant, from Google Drive, offers a different lesson:
Immediately, I have so many questions. Why a sequenced shortcut instead of something simpler, in a space where there aren’t that many shortcuts? Why Control of all things? On a Mac? Why is it so different than Google Docs in every way – don’t you all talk to each other? And why not a proper typographical symbol for Control (^ is not ⌃)?
But there is also a mechanical lesson here. I’d encourage you to actually press any of these three shortcuts, and watch your fingers doing that. I bet you will observe one of two ways:
⌃ down, C down, C up, ⌃ up, F down, F up
⌃ down, C down, C up, F down, F up, ⌃ up
Turns out, people are messy when it comes to modifier keys. That messiness was even encouraged from the very first day we breathed life into the very first modifier key. Most of 20th century typewriters had a full stop and a comma on both shifted and unshifted positions – pressing Shift was heavy early on, and this helped when punctuating all-caps sentences or preparing for a capital letter starting the next sentence. (Also, Shift Lock wasn’t as smart as Caps Lock is.)
But even without that encouragement there are still two legitimately valid ways to understand “^C then F” – you release ⌃ before the second key, or after – but Google Drive only listens to the first one. Couple this with giving you zero feedback after ⌃C, and I won’t be surprised if many people try this sequence once, and give up assuming it’s just not working. So, it feels it’d be good to think about being extra forgiving here, the same way it’s good to think about “coyote time.”
As always, please let me know if you see the method in this alleged madness. After all, the goal for this blog is not to blindly ridicule things, but to learn together through thick and thin.
Somewhere next to optimistic loading and optimistic saving exists another technique to make apps feel faster: optimistic committing.
Flickr is a great example. After navigating to photo upload, you enter a sort of a foyer where you can drag in the photos, reorder them, name and tag them, and otherwise prepare them before pressing the big Upload button.
But Flickr also optimistically assumes you will press that button, and slowly starts uploading the heavy photos in the background the moment you drag them in.
Like all optimistic schemes, being friendlier toward the user complicates things for Flickr’s designers and engineers. After all, there is still a regular upload modal after you do commit to the upload…
…so the two states – quiet staging area upload, and the official visible upload – have to be reconciled and kept in sync.
Also, optimistic but eventually cancelled uploads have to be cleaned up from the servers.
Lastly, there’s signposting. Contrary to lighter optimistic loading schemes, which typically simplify reality by pretending no data transfer is actually happening, the optimistic committing here is actually visible through small indicators:
I think this transparency is welcome. In the past, Meta (who else!) got into hot water for abusing optimistic committing:
Did you ever record a video on Facebook to post directly to your friend’s wall, only to discard the take and film a new version? You may have thought those embarrassing draft versions were deleted, but Facebook kept a copy. The company is blaming it on a “bug” and swears that it’s going to delete those discarded videos now. They pinkie promise this time.
In this context, it’s good that Flickr conveys data is being sent to the servers; I believe this helps with building trust.
On top of transparency, I think it’s also good that this process shows the progress of uploading with a lot of precision – not just between files, but also within each file. Internet connection speeds vary so much, not just geographically, but also even situationally, that this is really helpful in practice. There are many moments where auto saving to the cloud needn’t bother the user unless the connection goes offline for a longer while, but this feels like a situation where clarity is better than magic.
