Bug Blindness
danluu.com
danluu.com
For developers, bug-blindness tends to be because their mental model is so close to the system's model that both have the same blind spots, and the developer can't effectively think outside the system (the classic "QA walks into a bar, orders 0 beers, orders -1 beers, orders 0.999 beers" vs "customer walks into a bar, asks where the bathroom is, bar immediately bursts into flames").
On the other hand, a common way for regular people to interact with a system is they just... don't have a model. None at all. Like, they click a thing and see what it does, and if it doesn't do what they expect they shrug and click something else. The horror of seeing a non-software person using a software system is realising that they usually cannot tell the difference between expected and unexpected behaviour, because they don't really form expectations in the first place. The computer is more genie than machine.
You can see this in the article: "Google Docs added some kind of delay such that the typing you do into the title box right after you open the doc gets overwritten". That's a developer forming a model of the system. The lay alternative is to simply learn that sometimes when you type in a box, the text appears. Other times, it doesn't. If it doesn't, you try again.
You don't need to understand the system if you abandon the assumption that the system was designed to be understood. And, in practice, the widespread plagues of shitty engineering, anti-features, and lack of respect for the user often combine to make that model the more information-theoretically optimal one.
In that sense, the very thing that makes us miserable is our perverse need to treat Google Docs as an engineered product rather than a cross between a djinn and a symbiotic fungus.
This is completely lost on most developers, which is why interface and UX designers exist. Developers, especially in FOSS projects, often love to condescendingly assert that users are just not reading the docs, or are not smart enough to understand the software. They’re smart enough— they just don’t want to have to learn about technical implementation details for the same reason most developers are perfectly content to use personal bookkeeping apps instead of learning the best ways to organize that data and making the spreadsheets manually. Most non-technologists get no dopamine hit from solving technical problems, have no need for the requisite knowledge needed to confidently do that, and are often just trying to make the computer do what it must so they can get back to doing what they’re actually passionate and knowledgeable about. When a competing product has an interface built for people without that mental model, it would have to be pretty fucking expensive to not be a no-brainier for most nontechnical users.
I worked at a small company that had a policy of putting devs on front-line support in a rotation, both because it was too small to have dedicated support staff and because the owners wanted devs to understand how users interacted with the system better.
I can assure you that while some users merely think differently than devs, there is cohort of users who are absolutely not smart enough. It's impossible to do any amount of front-line support without collecting some horror stories.
What eventually worked was getting them to spell it to me backwards. That strategy has worked out quite well in other cases too - I suspect because it avoids some of people's built-in autocorrect and dyslexia (autoincorrect).
(I honestly mostly enjoy tech support, and I've done it for many years, sometimes professionally. But some people do seem like lost causes, and are not just having a bad day)
What an example of a sentence a person *whose intelligence is lower than you might expect would write. I can only imagine this was intentional.
You may feel superior to the average IQ person right now, but we're all going to regress to that point & worse at some point.
Design software & plan your life accordingly.
It is missing the equivalent of the "history" in e.g. browsers and YouTube.
If a user dismisses an alertbox on desktop, why isn't there an history menu item that shows the previous 100 alert messages?
https://www.lifewire.com/iphone-notification-history-1189516...
1: you can't get access to actions or details in the history (e.g. no long-press to change settings), nor does it show you ones you didn't dismiss by hand afaict (I've been having Discord notifications disappearing almost immediately after making a noise, but there's nothing in history even though I saw it for its whole half-second existence because it popped over my screen).
Reflexively dismissing error message popups is reasonable behavior because they're almost always unhelpful. It is often easier to mindlessly trial-and-error your way around obstacles than waste your attention on them.
I have no idea why you think this. The only reason I wouldn't like it is because I might be doing something that requires incorrect code as a placeholder, but if the modal didn't come back after being dismissed (and just sat in a history) I'd be pleased as punch. It's why I moved to rust - I wanted the compiler to stop me.
Not only do you think this, but you think it's somehow a sign of being egotistical and disrespectful that anyone would like to know when they're screwing up. Weird.
> they're almost always unhelpful.
Sounds like you found the real problem.
As I explained earlier, what we were actually trying to do was debug the problem, and reading the error message was a necessary part of that.
It’s weird you’ve cooked up this little fantasy that the error message was getting in the way when it was the most important thing in the whole process and that was the entire point of the anecdote.
> Reflexively dismissing error message popups is reasonable behavior because they're almost always unhelpful.
Not when you’re trying to debug the problem the error message is telling you about!
By the way, I've seen the exact same thing in a student I was teaching how to use computers. He was asking me what's wrong and demonstrated that an error popped up, which he immediately closed - several times in a row! At the time I thought he wasn't really trying to solve it himself so he didn't bother with the message but now I realize it's just how people have reasonably adapted to the obnoxious way computers keep jumping in front of you screaming for attention.
Sometimes the reflex is so strong, it is extremely hard to stop it, even when you're aware of it. Something like that has happened to me once. There was some kind of password form, where it said DO NOT PRESS ENTER after typing the password. I pressed enter. It took me several attempts to get through it.
It may result in power users losing some features.
For example, no power user benefits from having to use work arounds to make a product function. It's an annoyance to them, and it's an insurmountable obstacle to others.
it can be in fact improvement for both but in many cases it is not
Otherwise, you can most of the time make a product which can be easy to use for novices while retaining maximum efficiency for experts.
Maximum efficiency for experts requires removing information that would be distracting and redundant for them, but essential for novices to understand the working model of the program, so you're pretty much wrong.
In the 2010s Mathworks, the company that makes Matlab, had a policy that everyone started in frontline support. Including developers. (They probably still have this policy, I don't know.)
It shaped attitudes and cultures quite a bit.
So what every support person lives thru on every day of work.
And really being a good support person involves figuring out what bucket the customer belongs in.
"Customers that are smarter than you and if they are talking to you, your shit is wrong somehow"
"Customers that are smart in general, but need some guidance accomplish more complex tasks"
"Customers that aren't very smart, but handholding works to solve their problems"
"Customers that are dumb, realize they are dumb, and persistent at being dumb"
and finally the worst
"Customers that think they are smart and are belligerent if their intelligence is questioned as they are doing something horrifically stupid"
The average IQ is 100, half of people are below that. Being surprised that customers may be of different intelligence is the kind of thing that comes out of people who have never had to work a retail/restaurant job in high school growing up. If someone has made it that far in life before finding this out, they've lived in a bubble.
People of varying intelligence levels can operate a motor vehicle and yet software can't be designed well enough for them? The failure may be on the SWEs.
I also think the ego stroking borne from disproportionately high labor demand has given many developers a serious case of main character syndrome.
Automobiles and the international road network have also had well over a century to standardize themselves over a glacially slowly changing set of expectations while we're writing drivers for 400GBE chipsets that only got invented last Tuesday and building agent management harnesses for styles of neural networks that literally weren't even a twinkle in the milk-man's eye yet as recently as fidget spinners being in style.
How many bad UX redesigns do major desktop/phone OSes need for their phone/text/mail/photos apps?
We're at least 30 years into email apps for example, and yet the UX changes year to year for.. reasons.
This means that if there is an actual, finite button on a corner, the easiest way to click it is to position the cursor on the very corner, rather than attempting to position the cursor in the middle. But this is ruined if this button has padding. So for example, the start button on windows at the bottom left corner had padding in earlier versions of windows like windows 98, but the actual hitbox of the button shouldn't have padding, so that it's easier to click.
This is all to say that I use Firefox maximized, without a titlebar or menubar, so that the "back" button is at the top left corner of the screen, and the hamburguer button is at the top right corner. But those buttons have padding! If I actually move the mouse to the very corner before clicking, I miss the button
That shit is infuriating
That would be Fitt’s law, which - if you can believe it - dates back to 1954!
But besides being overly pedantic I agree with your general point. If their is a small gap between hitbox and edge of the screen it is very annoying.
But the worst thing IMO is Windows 11 windows which you can grab by the titlebar but not the content area. However often there is no visual indication of where the titlebar starts/stops.
"Back" is used so frequently that I consider any mouse lacking a side button for "back" to be incomplete. You don't need to put a high value on your time for upgrading your mouse to pay for itself within its service life.
So I usually only map middle click to such a button, as that button is at least 90% of the time relatively safe to accidentally trigger.
Good UX I believe doesn't mean that the implementation details are hidden, but conveyed in a way that is human-readable. You do not hide the machine from the man, but translate between them in a way that makes neither of them invisible.
This makes for better experiences, as reality gets bound by.. well.. reality. So you don't get these weird failure modes that live in the gap between the narrative (e.g. "everything just works") and reality (e.g. "networks are always black magic").
This is also important for the user, because by having _a_ mental model (even if it is very low-res), they gain the ability to diagnose issues themselves and not be completely helpless once the magic box breaks down. They might not know exactly what to do, but the direction is very clear.
Agency is important. A lot more important than convenience. And fake convenience through frontloading short-term rewards for long-term systemic instability.
This is where skeuomorphism used to be king before computers ate the world. In the 90s everybody knew how a paper book worked, so document readers presented as books. Everyone knew how a tape deck worked, so audio apps presented as tape decks. Floppy disk as save icon, etc
Unfortunately, the passage of time is inexorable, and by the late 2000s we had a lot of users who had never actually seen a tape deck/floppy disk. And the whole skeuomorphic project came crashing down.
> In the 90s everybody knew how a paper book worked
I hope that’s still the case!
It's hard to call this an example of "skeuomorphism". Those icons were introduced on physical buttons with a certain meaning that everybody had to learn. They have exactly the same meaning on software buttons; the interaction that people have with them now is the same interaction that everybody has always had with them.
This isn't a case of the software appealing to a visual metaphor that made non-metaphorical sense before the software. It was just as much of a metaphor originally as it is now. You might as well call the word "edit" a skeuomorphism in modern software because past software also had "edit" menus.
Right, that was my point. What does it matter what a diskette used to be? Unless something more obvious to convey storage/saving comes along, it’s hardly “crashing down” anytime soon.
Play and pause icons aren't skeuomorphic. They're symbolic. There is no point at which they were a reference to some phenomenon earlier than or other than themselves.
The double-pipe pause symbol originates on the video side, where pausing keeps displaying a freeze-frame image, and stopping does not. Audio players had pause long before (which just causes the drive wheel to un-grip the tape), but used a variety of different symbols.
> "[play] The meaning "to cause (a recording) to reproduce what is on it" is by 1903, probably from the "make music" sense." - https://www.etymonline.com/word/play
We should distinguish between skeuomorphic interaction design and skeuomorphic iconography. Attempts at skeuomorphic interaction design did fail badly, I'll give you that. Document readers that expect you to turn the page by pulling at the edge of the page, mimicking a page turn in a physical book, they're terrible.
But skeuomorphic iconography works: The more detail you add to an icon, the easier it is to form mental associations with what it does - and that goes even if you don't know the original object that it's based on. Sure, a lot of people have never seen the floppy disk that the traditional Save icon is based on, making the icon less intuitive now than when it was designed. But what would you replace it with? Any alternative you might suggest is just going to be less recognisable.
Obviously you replace it with the three stacked cylinders that symbolize a hard drive. ;D
It would be like if smashing magazine put out an article in 2015 about everybody moving to a “microservices architecture” and then any time any kind of software development came up in a design forum, someone would awkwardly shoehorn the discussion into a framework of microservices vs monolithic applications. (Even better, when a developer would come along and try to give a more nuanced perspective, the designers would see themselves as the authority in the conversation because all the other designers around agreed with them.)
If you really want to dig into the nerdy conceptual side of icon design, triadic semiotics is the far more interesting rabbit hole to fall down.
In the era of web apps and Electronification of anything I believe most of this is sadly gone, but in the older Mac OS X models you could clearly understand and see the logic behind the software and I believe it worked well for non-technical people from what I observed.
A nontechnical end user generally isn’t interested in operating a toolkit— they want to solve their problem, and the application claims to do that. The easier it is for them to get from problem to solution, the better.
When a developer sees a software interface, they see a palette of commands and parameters to pass to a software back end. Understanding that, and it’s implications, took years of learning and intensive usage that has blended into an imperceptible base layer of technological understanding.
To a nontechnical end user, the interface is the software. The button might as well mechanically do something. For whatever reason, often because they didn’t find it interesting, or their cognitive skillset didn’t easily adapt to it, or they just didn’t have the exposure, they didn’t learn about the basic structure of applications, and they’d be years away from understanding it enough to make decisions based on that.
Flexibility and power yields agency for technical users. It blurs obvious pathways and dampens signals for nontechnical users that just want a problem solved.
It’s difficult for experts to see things with novice eyes. That’s one of the most important things a designer can do for the software building process.
Fundamentally, interface design is a communication discipline. There’s a reason it’s a field unto itself, with its own degrees and professional organizations, and there’s a reason it’s often taught in art schools. There’s also a reason that every significant user-facing interface in your life, from your text messaging apps to the ordering kiosks in restaurants— none of which need documentation— were created by designers and not developers. Looking nice is not the point — it’s often a side effect of clear and deliberate communication, which is both difficult and important.
The older I get, the more annoying I find this habit in the SWE community. It's not even a well earned condescension. Software is often horrible! Physical hardware products are not put out into the world with the kind of defects that software so regularly is.
We get away with it because we say we can patch it later, though often all we do is move defects around.
It's amazing picking up pre-internet connected era electronics from 30/40/50 years ago and they just.. work.
Meanwhile software decays at a faster and faster rate each year. I am coming around to the idea of keeping air gapped old-OS machines around just to maintain pieces of software that otherwise auto-update themselves into oblivion.
There are some well reported bugs in Microsoft/Google/Apple that have persisted for years. Nobody cares.
Well, Jira does that too in many of its input widgets: anything you type while the page is loading is cleared after the page is loaded.
At this point users have been conditioned to accept this sort of react crap.
In this scenario, you only need to cater to the most clueless users. There is no need to make an app learnable as you don't even intent to keep the users long enough for them to actually learn how your app works.
This applies to software engineers too. Especially now there's claude to help them complete the tickets without understanding the system.
GitHub also introduced this feature recently in the New Issue GUI.
I suspect that's part of why fuzzing is so powerful.
You could always tell when it was someone’s first time watching a real user attempt to use our website.
Things like this just infuriate me. The user just learns that things are unreliable. To me that's unacceptable for something to be presenting a text box to type text, let you type it, then wipe it out. Sometimes you have to wait a second after typing something before clicking search, or it searches for your incomplete query a half second before. I don't blame users for just concluding that typing is unreliable.
"In some cases, people sent me their actual search results. In every such case, the search results did not contain a good result that I could see"
Software that does not meet expectations, especially in a field like search, which is basically a long running war between SEO and search engines, is not a 'bug'. That's like saying there is 'bug blindness' in the publishing industry because when I pick up a random book, it sucks, even though others think it's fine. Sure, maybe something is wrong, could even be improved, but lets save the word 'bug' for something more specific.
A bug is when actual behavior does not match stated or intended behavior. If the search bears little connection to what was searched for, then it is a bug, as far as the user is concerned.
Or maybe you mean to say we should reserve the word bug for deviations that are unintentional?
- The thing the user searched for doesn't exist, so it wasn't found. This is not a bug.
- The user did a good job of searching, using relevant keywords etc, but the relevant thing (which exists) didn't come up. This is a bug.
- "Search didn't read my mind" -- if search is a core competency this is a bug, but otherwise I would consider it a deficiency or a missing feature.
> If the search bears little connection to what was searched for, then it is a bug, as far as the user is concerned.
A bad product perhaps, but not a bug.
What about if B has no connection to A whatsoever? Still not a bug? If it is not, then we may have discovered a software domain (the first for me I should say) where bugs are not possible. Should a be a nice market to launch products for, then.
It depends. There could be a bug in the system like query = query.replace(A,B), or it could be that there are no good results for A. Returning nonsense results is a bad design, but not necessarily a bug.
I guess my underlying point is that bugs are about software not conforming to some specified behaviour, and trying to specify behaviour like "i should type in a search and get great results" is too loose of a spec to be meaningful so we should avoid saying things which don't meet that criteria are bugs. To use a concrete example, perhaps the set of search results returned for a query look useless to you but are actually useful for someone else.
Compare that with something like a calculator app where part of the spec is "Must handle integer addition with for inputs i,j where -10,000 <= i <= 10,000 and -10,000 <= j <= 10,000". Then if in your calculator you do 1+1 and get 3, then that is clearly a bug per the spec.
Bugs vs. bad design is a useful distinction to make imo.
In products your users are stuck with it doesn't matter much, they'll have to suffer with what they think are bugs.
In products that users can switch easily, you can get dropped for a product that you would consider crappier if the user believes it's less 'buggy'.
It depends entirely on the commitment made by the service, so e.g. my desktop file search program results has bugs whereas Google's has none.
But this article is in my opinion one of the best attempts at explaining a fundamental problem in software product work that has never (in my experience) been laid out this well. I will implore you to finish it.
While bug has various definitions, not meeting reasonable expectations is common to all.
> That's like saying there is 'bug blindness' in the publishing industry because when I pick up a random book, it sucks
No, because there's no reasonable expectation that a random book won"t suck.
Just like when a do a search and the results aren't relevant
Obviously this means both books and web searches are useless
The author explicitly says he is using less specific and compelling examples for good reasons:
> I don't want to give any specific examples where it was my job to see how well the thing worked because, even if the internal examples are meant in a constructive, blameless, way, they may not always read that way when re-posted externally, so I'll give a few less interesting and less well supported "random" examples.
I also think it's reasonable to use the term "bug" in a broad or colloquial sense. If a web server is overloaded, that isn't a bug in the strictest sense, but it sure feels like a bug to the person trying to use the website. A search engine is software, and if it fails to surface the most relevant document from its index then I'd say that counts as a bug. Also the author acknowledges this SEO spam issue, e.g. in this quote for the linked post:
> Here's a fun experiment to try. Take an open source project such as yt-dlp and try to find it from a very generic term like "youtube downloader". You won't be able to find it because of all of the content farms that try to rank at the top for that term
> Blackboard (as well as Epic and SharePoint) are classic examples of software where the user and the purchaser are different and the purchaser basically doesn’t care about the user, so you don’t expect the software to be good and it would be a bit of a surprised if the software didn’t deliver a bad user experience. But it was even more surprising to me that someone working on some of the most reviled software out there could think that the software was widely loved.
I worked briefly at Epic and the attitude there seemed to be more like "yes we know people hate Epic but they're wrong". :P People there didn't think Epic was widely liked!
(The explanations given were basically, 1. people hate Epic because their IT department configured it wrong, if they configured it in a more suitable manner they wouldn't have these problems, and, 2. it's not Epic per se that's the problem it's all EMR software, if you think Epic is bad you should see the competition, they're even worse. I'm not sure that second one is really such a good excuse, but, that was what I remember hearing.)
As it so happened, within a week of this occurring they needed urgent care, badly, no joke. We have basically three choices here (at least, which would take this insurer), and none of the three would see them, and the reason was the same in all cases: 1) they no longer had Medicaid, and 2) the provider couldn't let them pay cash and sort it out with the insurance company themselves.
It took three days calling the insurer, providers, the State health exchange, finally getting the insurer on the phone DIRECTLY with one of the providers... at a clinic rather than in admin... the insurer directly telling the clinic administrators that the person was insured and the insurance company would give them a claim number right now, or something like that... before we could get them in to see a doctor.
When we got to the clinic they looked them up and STILL told them they couldn't see them we had to demand to speak to an administrator and basically THEY COULDN'T CHECK THEM IN TO THEIR APPOINTMENT in their computer.
All of these providers used Epic. I made some additional phone calls and had some additional conversations, made a writeup, and sent it to the insurer, the benefit exchange, and the provider who ultimately saw us. Never heard anything from anyone.
Seems like reader mode is needed due to bad defaults.
After all, he is complaining about the defaults in other software, but he is blind to the defaults he presents the user.
body {
max-width: 70ch; /* Limits the text column to a comfortable reading width */
margin: 0 auto; /* Centers the text column on large screens */
padding: 1.5rem; /* Prevents text from touching the edges on small/mobile screens */
line-height: 1.6; /* Gives the lines room to breathe */
}
font-size: 1rem;
The problem is you're imposing your own idiosyncratic preferences on strangers. Your "improvements" cost valuable screen space. I paid good money for my screen space and I don't appreciate designers unilaterally wasting it because they personally think it looks better. The decision of how much (if any) space to spend on padding should be made by the user.
There are also large-scale studies.
Btw, WCAG recommends 45–75 characters with a limit of 80 characters. Why not follow their recommendation?
It doesn't achieve a reasonable readable font size which was presumably the goal. Your padding won't be the right size for all screens either. (And personally I hate excessive line height).
> respect the browser's default font size
The browser's defaults are also bad. But they shouldn't be. The browser is in a position to actually fix this; the webdev isn't.
What's bad about them? There is a sensible default and users (in particular those with poor eyesight) will adjust them to their needs.
Ignoring this default is presumptuous.
16pt is a sensible default on some screens and very much not on others.
> users (in particular those with poor eyesight) will adjust them to their needs
In the real world they won't though, much as we might both wish otherwise.
I use Firefox reader, but the same idea. I actually prefer it this way (except I don't like that the reader doesn't support Vi/Emacs navigation...)
For content that is just text, I prefer that the author keeps the styling to the minimum. It makes it easier to do it the way I want it client-side.
Speak for yourself.
Font size is client setting, and there's where lies any bug.
I run into 10 to 20 software bugs a day (feels like more). If it wasn't for the all the private data I'd leak I sometimes wish I could just put my phone and computer on screen capture for a week, with input data (keyboard/mouse/touchpad/screen) and then come back and post the 100 bugs I hit that week.
I've run into the MacOS one mentioned, getting a black screen on opening the lid. I've also run into iOS Camera app failing to open the camera. I've run into the iOS keyboard only using 80% of the width of the phone (all the keys smaller). No idea how to fix that. Closing the keyboard and re-opening does not. And killing the app, whatever app, is out because I'm in the middle of filling out a form and don't want to have to start over. I've had the phone's screen freeze quite often recently, no response to any finger presses. Locking and unlocking the phone recovers. This one is new (started happening 1-2 weeks ago)
Common/not-common. Any app that uses the phone camera to scan things (checks/ids) almost always fails in one way or another. Doesn't recognize the thing or times out like the only way they tested was in perfect conditions in their office and never tried with real users.
wow, you just reminded me.
From time to time I bring up the camera app, and I just get a blurry screen. I have to lock the phone and unlock it, maybe quitting the camera app before I get the camera app coming up showing what the camera sees.
I just worked around it and got on with my life and didn't yak-shave (search for a solution or file a bug)
Are you sure you're not triggering the compact width keyboard?
this is similar to what happens to me, if the screen goes dark to save battery and I move it to start back up too quickly, like within a couple of seconds, it will crash and restart.
So sometimes I see it is going to go dark and I move to stop it but it goes dark a microsecond before I touch the touchpad and then everything needs to start up again.
But nobody cares. Posting bugs is mostly pointless, it's wasted time. Nowadays even for paid products quality is not a priority.
Likely the one handed keyboard feature: https://www.reddit.com/r/iphone/comments/1mi7kjd/til_onehand...
After owning it for a while, I came to learn that it was not a great car. Things constantly broke and the repairs cost me more overall than the cost of the car. A complete disaster.
I came to realise that to a mechanic, little problems like an old fuel pump or poorly maintained engine were "easy" problems to fix. To my brother in law, what mattered was the low price and the fundamentals. Repairs, to him, were easy. To me (not a mechanic) they were expensive and inconvenient.
I think, for a developer, problems with software are a bit like this. Little things that are easy to fix can be overlooked because the grand design of the system is very clever or it has some advantage over other software like handling a particular file format, or processing a high volume of transactions.
Personally, I find it very difficult to sit down and expend the attention and effort to really look at and test my own software. I think because every little issue that I see becomes another job, another hassle, another delay in releasing. Maybe thats my "Bug Blindness", not sure if it's the same.
Recently things got way better with hardware support - but just making a printer work, used to be a unsolvable problem for my dad for example, who has a electro engineering background (but doesn't speak english, and error messages in linux are very seldom localized). In windows he put in the CD that came with the printer and it worked.
Since Windows 7 or so, I have seen the ease of installing a new printer driver in Windows rise to the level that Linux had always been at in my experience (I realize other people's experiences have differed). But it was shocking to me how easy Linux printing was for so long, vs how much I struggled when I had to install a Windows printer driver.
- You can't build a model, because everything will be changed with the next update, so, even if not consciously, people won't do it, why bother learning something that's not going to be of any use next time you use the application.
- because you basically don't know how anything works, it's a coin toss whether it's actually not working, or you're just "using it wrong".
- most things won't do the thing you expect of them consistently, so you don't expect anything of them.
Last night, I uploaaded some documents to my insurance company => modal:
- Title: "Files successfully uploaded"
- Text: "An unknown error occurred"
- Button: "Ok"
Thank you.
I suspect I know why they do not notice. See below.
>it works well, etc., but when I open up the thing and try it, it's in a state where the thing only works if you do quite a few non-intuitive workarounds.
I suspect most people are so inept at navigating UI because even a good UI is not intuitive to them. A bad UI is equally not intuitive. They do not know it is a bug because everything is a bug to them.
I can use a novel UI and figure out where to find what I need to do very quickly. In my experience with lay people, they can use the software for a decade longer than me and still not understand some of the capabilities and navigate to utilize them as I can within a few minutes or small amount of research.
Shoutout to https://grumpy.website/. Love it.
This seems a weird thing to believe given that we know there are such things as black UI patterns designed to keep users from doing things they might want to do, but which the company might not want they do yet still are obliged to provide the possibility of doing.
As a general rule I think I am pretty good with finding out things about software, for example in pretty much every company I've worked at I'm one of the only devs who learns Jira's query language, and how to make my own dashboards to organize things, but I do at times experience UIs that I either must believe are malicious or buggy, and I stand by that interpretation no matter how they people who work at the company like to claim it is working as intended.
But I have also experienced some times when I think the way this UI works must be a bug, because otherwise the people who designed it must be incompetent idiots and also, given laws about accessibility requirements, potentially on the hook for some monetary payments in court soon.
My interpretation has been that I am often to quick to think things are bugs and not worthwhile using because I am familiar with how buggy things can be and still "work" somewhat, and also that normal uneducated users will try to soldier through things I just give up on because they don't realize that a thing should not be working the way it does, they think it is them that are wrong - as evidently you do as well. I think it is frankly a strange viewpoint to have in the world of software development, which world I assume you are a part of?
I agree with, "They think it is them that are wrong", essentially. The end users that I deal with at the consumer level usually think they messed up when something does not do what they thought it was going to do.
>as evidently you do as well. I think it is frankly a strange viewpoint to have in the world of software development
Can you elaborate on this statement? I do not know whether you are agreeing with me and implying we are both strange or you are implying that I think that way and that is strange. Either way, I am not a developer, yet. I dabble in things.
The users who don't know how often bugs occur and so forth always think that it is them to blame, but people who know about bugs and how things are made should probably think otherwise, but it seemed the way you phrased your initial post that you are in agreement that it is the fault of the users for whom the UI is always nonsensical and who never put in the necessary amount of effort to understand the UI.
Under Windows: Don't put your files into "My Documents" or similar folder hierarchies; you never know if old software will correctly deal with the abstraction.
Working with files in general: Avoid nonstandard unicode names or long paths so your external hard drive doesn't choke on them. Avoid case sensitivity even when it is allowed on Unix systems, since you can't assume Windows won't ever touch them. Avoid whitespaces in names because sooner or later, some script won't escape them.
On the internet: Never draft long comments in the browser; always use a local text file. Anything can happen in the browser.
In games: Never save your game during what looks like a complex scripted scene even if the game does allow saving.
Using search engines: Avoid keywords that are likely to confuse/distract the search.
With dropbox-likes: Give it some time to sync even after the icon is green; god knows what is being predictively shortcutted under the hood.
Everywhere: Restart the program or system if certain signs of corruption appear. You don't know what's going wrong, but you know something is, and barring some unusually careful compartmentalization, a piece of software is still a state machine which, once it has strayed from the right path, cannot be trusted at all. OSes nowadays are adapted to this, but much of software is not, and you do not want to have it corrupt your file.
The second one is most software contains bugs. Users that expect to get things done simply choose workflows to avoid the worst consequence of those bugs very quickly.
I feel like a substantial source of everyday irritation are bugs like this in bad software. It’s frustrating that devs just don’t care.
You could make software that doesn’t require your users to work around its shortcomings.
If the users are missing the mark so bad that they're wiping their asses with suede, I'd argue the documentation and examples are at fault.
They were paying exorbitant amounts of money for the license too.
A University must comply with Laws and Regulations X, Y, Z, P, D and Q and a host of other regulations the University never heard of and Blackboard went through the process to "comply" with those checkboxes. So, if you deploy Blackboard, you tick all the checkboxes automatically.
The fact that Blackboard was a garbage content management system and a terrible grade recording system was irrelevant--because the "better" systems wouldn't check the boxes.
(I say this as someone who, as a lecturer, had to manage the account logins, mailing list, and Subversion source control system for an entire class. I only ever put grades that needed to be "secure" into Blackboard. I did all that because I HATED Blackboard that badly, but it was a LOT of work. And I probably wouldn't have passed any significant security audit; although my accessibility ratings should have been excellent since everything was plain text and plain HTML)
It is definitely true though that enterprise software for nonprofits (like education) sucks even harder than usual, because nonprofit IT departments don't even have the profit motive to align IT department and end user interests.
Users don't choose their university by how good that university's software is (just as we don't choose apartment complexes and power companies this way). This gives university IT no incentive to deploy software that doesn't suck.
Banks and cellphones also used to work this way, until they suddenly didn't, which was quite a shock to the existing players in the market.
The reason for this may be evolutionary (although we don't know what traits were the most effective to help us survive in the wild); but there is a very practical reason to ignore signals, which is that there's so may of them: if we did process every data sent from every sensor and thought about odors, light, temperature, noise, etc. then we would be overwhelmed and could not do anything else.
That's also why we usually don't "see" things or people: we identify them. We don't see faces, we simply identify Alice or Bob. Which in turn explains why most people can't draw: the concept of Alice can't be drawn; to draw Alice we need to actually follow the features of her face. Being an artist means being able to unlearn (or disable) that identification process.
And I think the reason most people don't see bugs is similar: they're not interested, all they want is to get something done. If there's a simple workaround that makes the thing work, then that's good enough; all the rest is irrelevant. This is not bias or benevolence: this is efficiency.
I asked him why he does this. His explanation was really built on this operant conditioning idea: "we use this stuff for 8 hours a day and we train ourselves to avoid all of its little pitfalls. So I get the most available person who hasn't used it all day, which is our manager. He uses it differently than we do because he doesn't avoid all of its little problems. But if we have a really tricky problem, I get our manager's manager. I don't know if you've ever seen him try to use an xbox controller, but he has the spatial reasoning abilities of a goldfish. He's never failed to reproduce a really hard bug. If I ever needed an Einstein-level bug reproduction, I'd track down the head of the department and put him in front of it, but it's never come to that.
- E.M Forster, The Machine Stops, 1909
"I easily observe hundreds to thousands of bugs per week"
which should be rewritten as
"I easily observe hundreds to thousands of things that I consider to be bugs per week"
which is to say that the "bug" is in the eye of the beholder. It seems the author stretches the definition of "bug" to include cases where something functions, but in a manner that is open to improvement or not to his taste.
> he distrusts the research on the impact of line length on readability.
`<link rel="icon" href="data:;base64,=">`
https://github.com/mozilla-firefox/firefox/raw/refs/heads/ma...
Rather than having the website author wrap lines at a width that works for the average user or use case (which may only be optimum for a percentage of users or use cases, which may not include me), the user can simply make their browser whatever width they prefer the lines to wrap at. This way, everybody gets to choose what works for them.
You must find it difficult to read books, magazines, newspapers, as all of them have short lines
In my experience, books are mostly OK, as long as they don't split up the text in columns. Magazines and newspapers often do have columns that are much narrower than I would like.
Part of the issue is that I read fairly quickly, so I find myself spending a relatively large percentage of my time skipping to the next line, and it's that frequent context switching that is annoying.
There are very few websites without those columns.
Let's say my preferred text width is 10 units. Due to sidebars, most websites require a browser window width of 20 units to show me 10 units of main text.
Then I visit this person's website and get text 20 units wide and it's very uncomfortable to read.
The text width I like doesn't change but the browser window width I need does change, and I don't want to change it when navigating around, to be honest.
I guess I could use the browser functionality to inject my own CSS rules for specific websites, then I could change the single-column no-max-width websites to show me a sensible text width.
But I also suppose that I'm not alone with this preference. I believe there have been studies about a suitable line length that is easy to read, and this is reflected in printed media. So those websites ask everyone to make such changes. That doesn't seem right.
Are you maximizing your browser’s windows?
I reckon there's something interesting about human variety in focus and/or visual processing this tells!
Let's flip it around: Suppose someone put in code/markup to prevent any viewer from picking a larger or smaller font-size. Would that be "just fixing a bug", or would some of us be pissed that the author has dictated something in a way which infringes on our autonomy and disrespects our superior-knowledge about what constitutes our good reading experience?
Every time I have to go back to the article (usually after having already read most of it) and notice "yes, it's using the whole browser window".
I think you can obtain the common experience of one sentence per screen and lots of scrolling by pressing ctrl/cmd and plus a couple times.
>I find this last category a bit mysterious, as when I look up discussions on how the thing got into this state ...
I'm currently on the dev side of such a product and can tell you one way it can end up like this.
Leadership decides a new feature is required, but refuses to commit to writing what they want. Through a bunch of meetings and calls developers have learned a number of vague requirements to the product, many which are conflicting, just as many are unclear if they are long term features or needed immediately.
The result is something that implements - to the letter, but not the spirit - of what the developers can agree on from this vague mountain of requirements.
The feature is returned to leadership in the hopes that having something tangible will make it clear what leadership actually wants.
However, leadership returns with a "Looks great, can you add?" and they sign off and we begin the next sprint.
If you mean that leadership IS the business analyst, then you are in trouble :D
What are the odds!
> when opening a new Google Doc, I used to immediately put the title I wanted into the doc. At some point, maybe ten years ago or so, Google Docs added some kind of delay such that the typing you do into the title box right after you open the doc gets overwritten, so I now have this habit where, after opening a Google Doc, I do something else and then I change the title.
I seriously doubt Google is going to do anything about this behavior, though.
There weren’t any concrete examples of bugs besides the Google Docs issue. Like what was so bad about blackboard (I also remember thinking it was terrible). There was a link to a great article about search but again no specific example here. There are a lot of words but not a ton of new information. Maybe I’m just bias against llms, this could have been written entirely without then for all I know.
In this case for some reason, I disagree. This post is engaging for me. I sometimes elaborate on how I came to a conclusion because that journey is equally as fascinating as the conclusion itself. While reading this authors post I was happy to see what seems like a very thorough thought process.
It was actually refreshing for me to see someone write at such length and find myself engaged.
It worked for me.
Now, putting my self in your shoes, as I have regularly had the same opinion, I have more empathy and understanding for how people consume and enjoy writing.
The world is fascinating.
This deserves to be a separate post. Kagi would be great if it were 10x less expensive. For the price that is paid, the very first click should deliver the answer or most relevant information to the search with five nines accuracy. Clicks that require a user to perform more digging or are simply rejected as spam should come with some SLA of 0.0001%
(Not defending kagi necessarily, I've never tried it, no opinion on how it fares on today's Internet but comparing it to how 1999 Google did on the 1999 internet is absurd)
Haha it’s just that the things these devices enable for us are so valuable. But life is full of suboptimal things just because that’s how it is. Some other constraint causes it.
I was at Oren’s Hummus years ago with a friend and I remember thinking that there was this heat lamp outside by the window that was very close to the glass. We were halfway through our meal when we heard a loud snap and a large crack formed in the glass. Error in process, my failure to report it, and costly consequence. Bug, eh?
It’s just that the world is full of detail and things are full of interactions. And complexity is something we’re all constantly grappling with.
Every time I do the 5 finger gesture to bring up launchpad (I think that’s what it’s called) on a Mac the text field doesn’t focus fast enough for the text. Every time I type then backspace backspace backspace and type again. That’s just life. Somewhere someone shipped something that does this. It didn’t use to be this way but it is now. I can’t really change it so I just live with it.
The world of software is complexity upon complexity created from the fact that the virtual world admits arbitrary amount of interaction at much lower cost than the physical world. Yep, the world is full of bugs. But you really have to care a lot to stop them and no one really wants to pay you to do that.
A low bar means people walk past without realising it, a medium bar may take notice but it doesn't bother them and tends to get throw out within min or seconds. A high bar gets insane irritation that some may even call OCD.
And unfortunately, these spectrum follows an S curve. If you have a high bar, you are likely in the single digit percentage monitory. And the same is across all things not just software.
So... do we restrict the meaning of the word "bug" only to the mismatched (developers') expectations, or do we extend it to cover bad expectations too? I'm in the later camp, because I'm not aware of even a single company that has any department or a process that would systematically address the existence of bad expectations. And, if anyone should be given the power to act on it, the QA seems to be the most likely candidate.
Good thoughts and framing, thank you for that. I think I'm in the former camp, because I think fixing bad expectations is a matter of thoughtful redesign that should follow a slightly different process to fixing bad implementations (what I would call a bug). Not every issue in a program is a bug, and that has nothing to do with the importance or urgency to fix the issue.
Assuming a rigid product organization, I think developers _should_ ask testers to escalate "works according to spec" even if the spec is unreasonable. Otherwise developers might be torn between QA, UX, and architects fighting about how something should or shouldn't work. At least for me, finding myself in such a position is a recipe for excessive meetings and losing focus on other equally important matters.
But let me use Steve Job's phase, "you must start with the customer experience and work backwards to the technology".
A bug to developers is work according to spec, but a bug to a user is that is it has mismatched expectations. And it really should be someone's job to make sure this is corrected. But as parent said, there hasn't been one in most if not all companies.
And perhaps that is what makes old Apple such a success. They have a low pay $1 dollar salary beta tester to test out literally everything.
+ good contrast
+ good size
+ good line height
+ adjustable line width
And so on. On the negative side, it’s a bit ugly.
Wow, there's Obsidian, Kagi, and Apple in a nutshell.
The author mentions one explanation, which is that most people driving a Volvo won’t experience a breakdown (and then generalize from that). Another one is of a very different kind known as post-purchase cognitive dissonance (https://en.wikipedia.org/wiki/Cognitive_dissonance#Consumer_...).
If you can't write to the filesystem, almost everything you do in an embedded system will fail. So you can't undo a partial write. Your logging will probably fail too.
A relatively big database (a tier 2/3 database) that I was using handled this in a really bad manner: it'd just segfault. Depending on when this happened you could get data corruption and never be able to open the DB even in read-only mode.
It's one of the core principles of a database! And it didn't even do that correctly.
> I've had multiple jobs where directors/VPs/execs/etc. sometimes ask me to evaluate something when they want an actual opinion from someone who is relatively likely to notice issues (and fix them or drive fixes for them if necessary).
I’ve had the experience where I need to be asked, and even then, if my opinion isn’t “ist güt,” it’s often ignored.
When someone makes a proposal, I tend to immediately see the potential issues, and used to point them out, and suggest workarounds or mitigation strategies, without being asked.
Not the happy path. I get accused of being “negative,” my suggestion is shitcanned, and I’m shunned.
I’ve learned to just keep my mouth shut, and if the situation calls for it, start quietly preparing for when the wheels fall off.
I have also learned to never say “I told you so,” as that is a petty and vindictive statement. Doesn’t help at all.
> Not the happy path. I get accused of being “negative,” my suggestion is shitcanned, and I’m shunned.
Absolutely right. People come up with some of the most idiotic ideas, but you aren't supposed to point out the obvious flaws. These 'ideas' create a lot of jobs and success stories. The purpose of a system is what it does. Everyone wants to build an empire and they need more and more headcount, which means incredibly shitty ideas, and tons of people working on them. Everyone claims success and moves on to the next shitty idea next year for more success. Thats why, even if AI can make developers more productive, it doesn't really matter, the vast majority of projects in bigcorp are bad ideas. If your bad ideas go faster, doesn't mean it increases revenue or profit. It only helps the people involved to claim more 'success'. Now, with AI.
But there’s a lot of room between “perfect,” and the "quality" of most of today’s tech, and I worked for a company that routinely shipped gear that had a very high level of Quality.
I’ve watched people use “Perfect is the enemy of good” to justify shipping absolute garbage.
We can do better. Much better.
The whole "I see bugs where others do not" reminded me of that same phenomenon.
The QA guys flushed out the big bugs and many of the small ones. Without any proof, I imagine something like 99% of the customers would hit only a few bugs, that they are used to compensate for (reloading pages etc), leading to a view of the product as having good quality. I was wrong: the sw quality is poor, but the percieved quality is good. I would of course prefer to do sw of much better quality.
The software was crap, but it made money, so it wasn't crap.
The problem with contemporary software development is not only that often the majority of QA work is shifted left (meaning to the existing devs) but also that the developer mindset is contagious. Have QA-people, who are usually in the minority, work too long and too closely to the devs and they become blind.
I worked in V-model teams where the only communication between the development team and QA-team was supposed to be the spec. I still think that is the best way to develop software that works.
Paying for a product makes you defensive, especially if there are free alternatives.
I choose tools I use, configure them, report bugs, and occasionally contribute fixes. But when I can't, I work around them, yet never get used to the workaround.
"Habitual mitigation" does not happen in me, and it's partly intentional.
I have created bad software in the past, but when I saw how people work with it, I could not be proud. Learned to look at software like a user, and don't want to unlearn that.
I believe (or maybe I hope) software will be democratized and people will start to demand good software.
How do you write this article and not notice that this should be the topmost example of people adapting to buggy software that doesn't at all work for its users without workaround cognitive hacks?
It feels like too much of the benefit from it has been optimising, rushing new features/markets, tripping over ourselves with new processes, vibe coding things just for ourselves. When maybe it could actually make things better for most people using software in their daily lives.
I thought this is due to the "backfire effect", because humans perceive criticisms of things they like as threats.
I'm not sure what the term is for what you're referring to, although it's certainly a real and known effect.
Just once I'd like to believe, for a little while, that this industry has produced something worth being proud of.
Although I do have to agree with him about Linguist. I also have a PR that was reviewed and then just never merged, despite multiple very polite prompts over several years.
I'm pretty sure dedicated QA roles are a thing at many companies.
What they should be doing is having a goal of software that cannot fail to complete the task.
When I worked at Google, it was at least possible to report bugs internally with some hope they would be addressed. Sometimes you could even fix them yourself, given enough time and the relevant skills. Bug bankruptcy was still a thing. Teams would simply throw away all the SWE-years that had gone into documenting and reporting issues in their systems. But there was some possibility you'd get action, at least if you were a squeaky enough wheel and used the right back channels. But now that I'm outside the plex, there's basically no mechanism to report issues unless you're a tech vlogger with a large following inside Google or a >= $100,000,000 customer. Most other companies are much the same. They're not just blind to bugs. They're deliberately putting bags over their heads to keep from seeing what users are telling them.
This is why I find that it is better to wait a couple of months before actually do the final test before shipping your own software.
Fallback to the default is a design choice, even if it doesn't look like it
A few years ago I started leading a team working on a product that had a lot of „legacy” quirks like that. It took me a good while to set a strong quality bar, both mentally and technically. I would frequently point out where the mindset was wrong, prioritize certain fixes over project work, fix a lot of issues myself, fight with other teams to fix their stuff, run silly contests such as „who solves the most support tickets this month gets a prize” and sometimes even „stop the world” for a few days until we got something in order.
Some people might be prone to think their team will never have the time to do that (and some may be right) but in my experience quality pays back. Often fixing a small bug takes about as long as discussing if it’s important, properly filing it in JIRA and then communicating to the outside world it’s not the priority. And eventually you reach a point where you have way more calm and focus than before because nothing is burning.
This is classic "works fine on my machine".
I like to beat the shit out of my software when testing. Constant erratic scrolling and zooming, multi-touch shenanigans, pressing multiple buttons as fast as I can, using back gestures and the browser back button (if it's a web app), changing the window size and orientation frantically, and just all kinds of rough usage.
If your software can't cope with these things then you're doing a disservice to your users.
CS has been trained to close conversations, not to resolve issues.
I’ve reported critical issues with my bank where the accounting was broken, money was missing, transfers were inconsistent. Customer service loves to explain “well that’s just how the system works”.
Sorry no, the system has failed. It’s an accounting system, and by definition needs to be accurate, or at least report an error if it can’t remain consistent.
The same standards that would fail an interview are completely ignored for paying customers.
I'm a little confused, but as far as I understand this is a LLM-written post, isn't it? That would explain the very big length of it. Or maybe I've understood things wrong, in which case my excuses to the writer (which, in that case, could reasonably be called a writer).
"with LLMs, it's so much easier to look at data and figure things out, but the time it takes to write something up hasn't fundamentally changed"
Hahaha. Yup. That's me :) Not the screensaver in my case. I leave my desktop "suspended to memory" overnight, and when I come back in the morning / afternoon, to wake it up I press the Shift key.
But, more on the subject, I kinda find it disappointing that the post doesn't try harder to analyze why this happens to the developers. The explanation doesn't feel satisfactory to me.
This was my experience working on a product that was virtually universally believed by its programmers to be of good if not excellent quality, while, in reality it was atrocious. Just to give you a taste of the quality: Jenkins landing page didn't work because it would take too long for it to load and various timeouts that happen when it fails to load would kick in and just mess it up so much it wouldn't have been useful anyways. Jenkins tests were generated from some horror-show templates written in YAML (some RHEL tool, forgot what it's called) and because there was no other way to test what the template generated other than to deploy the new test into the actual Jenkins server, the server was full of dysfunctional "orphan" (no longer tied to any template) tests that were never deleted. The only way to navigate to the test results of the job you were interested in where to memorize the way the templated name would expand into the URI components of the Jenkins job URL, have some other test results bookmarked, and then modify the URL of the bookmarked page to get the URL of the job you want.
The CI/CD team, however, decided to combat this situation by developing their own server which collected data from Jenkins and displayed a table with the most recent results for select jobs. Green and red being used to indicate whether the job succeeds or fails, the table was mostly red most of the time, with some jobs being continuously red for many months.
Initially, I was hired into CI/CD team, but when I remarked on the desperate state of events in CI/CD department... they wanted me fired, but the company was going through acquisition and they wanted a higher headcount, so, they kept me, but transferred into the least relevant department where I would be as useless as possible: the quality control!
My life as SDET (because QA is a curse word nowadays) exposed me plenty to the situation described by the author. The aspects that the author didn't touch on is that programmers working on such a product that I've experienced a lot are:
* Unwillingness to accept that a large proportions of the product is bad. People have this intuition that some parts might be bad. After all, that's why QA exists: they find a few things, things get fixed, and everyone moves on. And this is how it works in passable quality products. But the situation when everything is on fire and is going to hell in due course sounds alarmist to the people who are on fire and are going to hell in due course. After a certain amount of complaints, all further complaints are dismissed.
* Unwillingness to accept the existence of strategic mistakes. The QA simply is not allowed to voice their opinion on product or feature design. The only way a tester can initiate a fix is if they can create a test that illustrates the problem. Saying, for example, that "our error reporting is bad because it's useless to the customer and it cannot be meaningfully reported back to the developers" was dismissed as "nothing to do here" (but, actually, meaning: it's above your paygrade).
I don't believe either of these would've been fixed by "simply pointing out the bug", as the author claims. Our industry came to a particular way of doing things that are pathologically bad. The way QA works is OK-ish, when the product itself is of an OK-ish quality. When the product is really bad, the QA is powerless to initiate a fix. QA isn't trusted enough, and, usually, is perceived as a liability, and furthermore, stuffed with engineers nobody else wants. Unless this is changed, the pathologically bad products (like the Blackboard) will have no hope of ever improving (eventually, they will just die either under their own weight, or replaced by something else).