I don't even like "We" in UI messages.

"We couldn't find that site."

"We're just updating your computer."

Perhaps I'm just an old fogey, but passive voice feels like the only right choice:

"The site could not be found."

"Your computer is being updated."

The insertion of "We" feels like an imposition; the company who wrote the code reaching in and enacting their will with your equipment, using your screen as their soapbox. It's icky.

And without "we", there can of course be no "we apologize".

I suspect there are cultural preferences here, there's no reason to believe there's one correct answer for all of humanity.

I'm from the US but I've traveled to places where it's considered rude to say "no" directly and apologies aren't common. Like when trying to order an unavailable item from a menu:

  - I'd like the beef burger
  - The chicken burger is very good
  - That's OK, can I have the beef burger?
  - Our hot dogs are also very good

Conversely, I much prefer quick and direct communication with or without the apology: "[Sorry,] we don't have the beef burger."

I'd love to hear opinions of non-US and non-Westerners on this. We're in a thought bubble otherwise.

Given the reference to "your administrator" the user-facing sorry seems fine.

IMNSHO, dev-facing error messages bifurcate:

    - errors for unsuitable input should not be apologetic:
        "inconsistent def'ns at foo:42 and bar:69"

    - errors for implementation limitations may be apologetic:
        "sorry, at foo:42 node bar has 69 attributes; this implementation supports at most 63"

I like my error messages to eschew anthropomorphisms.

Tell me what went wrong so I can figure out how to fix it. I don’t care whose fault it is or how very sorry they are for the mistake. Even saying “the website you are trying to contact is down” can be misleading, maybe it’s not down, maybe I’ve lost my internet connection or the ip changed and dns hasn’t updated, or I have some rule locally that is redirecting me incorrectly. Guiding someone into an assumption is harmful and a waste of time, if not dangerous.

I understand that consumer stuff is all about dumbing down the experience so that an idiot can do the thing (we should strive for the most idiot proof interface possible), but that design principle is useless when things go wrong and you need to fix it.

> it would be more appropriate to "apologize" for something that would be considered solely the "fault" of the application

Is this in part a US vs English difference? I used to work with somebody from Texas who was confused and irritated by the english use of 'sorry' for things they weren't responsible for. In english I suppose we use it out of politeness to express some sympathy, rather than necessarily as an apology.

I think prefixing with "sorry," is a good idea but I really hate cutesy error messages.

I feel the Chrome dinosaur kicked those off, and I do (did?) like the dino. But "it's not you, it's us" is very annoying. "We made a booboo UwU".

When something has gone wrong I really don't want to feel I'm being marketed to, I just want information!

I think, error messages should put way more focus on what can be done to make it work - rather than on what went wrong.

The user wants to achieve something, and the general job of the software is to help the user achieve their goal.

If the goal of the user is to book a flight - then the software throwing an error about the request form not being filled out correctly, basically constitutes a bureaucratic hurdle.

"You will not be allowed to book your flight, unless you ask for it in exactly the right way!"

Sadly, software often has to be bureaucratic about it's input - but that's not actually helpful to the user. So you could argue, when the software rejects the users request because of not meeting bureaucratic demands - the software is failing it's primary job: to help the user.

A perfect software would not have to show an error message ever - because it would be so good at guiding the user, that everyone would intuitively know how to do it correctly. But "Perfect" does not exist.

So any software will at some point inevitably fail to guide the user to their desired outcome and be forced to display an error message.

There's nothing inherently wrong with being apologetic in tone for failing to guide the user and putting such bureaucratic stumbling blocks in their way.

But the error message should be focused on helping the user. On making things work. It should not be condescending nor assigning blame. It should also be short and concise, and respect the user's time.

And that means that there's no space for polite verbiage and apologetic phrases.

So, apologetic tone is fine, if it can be done without increasing the length of the message.

However I would say that

"Sorry, you do not have permission to access this feature. Please contact your administrator for assistance."

Is not an error message, in the sense that it is not displaying an error state of the application. It is informing the user that some feature they have somehow reached (maybe through a link sent by someone else?) is not available to them. The apologetical tone is not for a mistake that was made (there was no mistake made by the application in this case) but for the action of preventing them from accessing something that is available to others.

| Sorry, you do not have permission to access this feature. Please contact your administrator for assistance.

What is the feature? What permission do I need? Who is my administrator? How do I contact them?

These are the more important points to assist the user with then adding a "sorry".

I'd argue that this should be a button with 'request read access to FooViz from your administrator' that facilitates the corrective action on the users behalf. Similar to clicking on a Google docs link that you don't have access to.

The thing that ticks me off is when a website has a cutesy patronizing tone in its error message, and it was them that messed up.

"Ooopsie! Looks like you clicked on a picture that doesn't exist!" Instead of "We fucked up and served you an invalid link"

I grew up using British software. It would be very polite.

  Please enter your name.

  Name:

  Error: null.

I think UIs should apologise if something that's not the user's fault happens (no network connection); be polite when giving orders (please do this or that); and be very precise when indicating input errors and suggest a course of action.

The only GCC error that apologizes (that I know of):

https://godbolt.org/z/GMxz5c339

"sorry, unimplemented". It really felt out-of-place when I first encountered it, but I think it messages intent a bit more than a simple "unimplemented" error message. It at least suggests that this is a shortcoming of the current implementation, so it might get implemented in a later version.

Having said that clang also doesn't implement this, and the error message doesn't apologize: "error: cannot compile this lambda conversion to variadic function yet"

I don't think users should be mollycoddled either, because that would be patronising more advanced users. It's just a matter of not making them sound too terse and abrasive.

Better still, have a failure condition that is symbolic in some way, or enforces certain intuitive interaction via the UI, instead of pushing error messages in people's faces. A good example of this, typing the wrong password in the macOS login shakes the password field, rather than displaying "INCORRECT PASSWORD!". That sort of thing.

I don't really care if the error message is cute or whatever. What I care most about is that you did everything possible to prevent me from even seeing the error in the first place. Then, once you've determined the error is not recoverable without user intervention make sure to tell me about it in a way that's actionable on my part. I should immediately know after reading the error whether I should:

• Immediately try again

• Wait some time and try again

• Change my input and try again, or

• Give up and walk away

Never met an app that could actually feel sorry (maybe someday?).

This type of behaviour just feels artificial and inauthentic in most products.

If your making an error message effort I'd focus first on being clear, concise and actionable. Try to establish some expectations for the user so they know how and when things will be resolved, ensure you're monitoring and alerting is appropriate to hold yourself accountable to those expectations.

If you really need to apologize, a human should do it.

I think a true apology should include, among other things, a plan on how you are planning on ensuring that the thing you're apologizing for doesn't happen again. So my rule would be: if you're not planning on ensuring that this doesn't happen again (either because the system is working as intended or because you have no plans on fixing the issue) then any apologize will sound insincere (because it is).

When is an apology okay: "The site is down temporarily. We are working to bring it back online. Sorry for the inconvenience"

When is an apology empty: "Your train has been canceled. We apologize for the inconvenience", more so when you hear the exact same message thrice a week.

Honestly, no. An error message shouldn't apologize. A good error message has the following conditions:

* Concise. ("You need to enter a number in this field, not text" = Good, "we're very sorry but we can't understand it if you write your age in text" = Bad).

* Clearly telling the user what went wrong without relying on technical jargon. The line number where something went wrong doesn't need to be in an error message; it's not something the user can do much with - keep that in the crash dump. The DLL name you're missing probably should be if it's from a runtime.

* Providing a means on where to find a more detailed error message/who to call to fix it if the user can't fix it themselves, with the right information to supply that person. ("Please call your administrator for help and use code ERR_CRAPSHOOT (128)" is good, "We're very sorry" with a ton of warranty warnings and a way too vague error code that can indicate a ton of similar errors is bad.)

* Avoid the notion of just reporting everything to some backend endpoint and giving the users no indications of what went wrong; this is only frustrating to the user, no matter how many apologies you put in the message. It's an answer that amounts to "your message is very important to us, please hold the line".

Completely tangent here but back in 2005 one of the early programs me and my cofounder wrote included a try catch which spitted out something like variable not found. We were just out of college and didn’t really pay much heed to the possibility of our code ever getting into the catch. And one of us had the variable christened as “baby”. Code went into production and one of user got the error message “baby not found”. Well thankfully our end user who found the error message found it funny and cheered him up.

So we go either helpful or quirky on error messages most often and apologetic if the situation demands it.

Yeesh, maybe this is why software grates on me so much these days. I know it's not human, and I don't want it to pretend it is.

No, error messages should tell the user what they need to do to accomplish their goal as concisely as possible.

Anecdotally, I’ve never seen an apology in the error messages telling you that your new password doesn’t include the right number or kinds of characters.

Edit: And actually I think this is a case that illustrates why error messages shouldn’t apologize. It would only make them less concise and beside the point.

Just write "Abort, Retry, Fail?" and call it a day

It worked for Microsoft, it will work for you

IMHO, super users are annoyed by the humanized responses. I don't want to see the error almost teasing me after I tried to accomplish something. Feels condescending. Especially the ones that start with Oops, Oh No etc.

I never liked the Windows confirmation messages "Are you sure you ...". If I answered affirmative, it completed the operation.If I replied negative, it never ever offered help deciding.

Maybe if they're Canadian? Though I can't fathom, say, Theo de Raadt ever adding apologies to OpenBSD error messages.

You know what's cyberpunk to me? Cyberpunk isn't about having robotic body parts and netrunning in cyberspace through your brain implants in a chrome-and-neon-encrusted arcology. Cyberpunk is owning a Taiwanese bargain-basement PC and booting Linux on it in 1995. Because like real punk rock, Linux was DIY and it showed -- it was messy. When you booted it up, there was no sugarcoating -- no warm and friendly bootup sound, no happy Mac smiling back at you. The various bits and bobs that made up a working Linux system started chattering to you -- all at once: first the drivers and kernel subsystems, then the init scripts, then some of the user-space daemons, all telling you unbidden how their day is going. Every component of the system told you what was going on with it, for good or ill. It would've been quite alarming to a normie; 1995 was far from the year of the Linux desktop. But I appreciated it.

And I resent error messages that try to mollycoddle me as a user. Apologies, "Something went wrong :(", and so forth. Just tell me, in the most rigid machine-like way, what happened. A stack trace would be helpful if the failed bit is open source.

I think the sorry helps the user to understand that something is wrong and it's not some normal part of a flow that they just don't understand.

Thank the Lord in the Spanish translations of software they drop the "sorries" and the "pleases". That much amount of grovelling must be some American thing I reckon.

Unfortunately some American companies are starting to cheapen out on translations by having them made in Mexico even for software used in Spain so the sorries and the pleases and some other spanglish terms are coming here.

I've been working in what might be called "UX" for some time, although mostly in technical and scientific environments, which are quite different compared to the garden variety consumer applications designed for retention and profit, and I wouldn't want to be thrown into the same pot as the usability crowd with their 90% business of self important shit that's just useless dribble for the incompetent middle management caste. The whole UX specialty can be summarized perfectly by the linked uxmag.com article which disqualifies itself automatically by having the most annoying, anti-usability "AI" bullshit modal over the article that's pathetically begging for the attention of gullible morons - of which there are plenty in UX, of course. It's a bullshit-job profession, and it shows. In reality you can boil down most questions of usability to using simple heuristics: Who are you dealing with and what's the useful interaction in this context? E.g. the useful interaction with UX people in any context is to let them know how little worth their professions actually has.

I always like to split error messages into two categories - developer-facing and user-facing. The former is geared towards diagnosis, the latter is an act of customer service. The two should never be intertwined - I see this happen way more often than I should.

When you present a user-facing error message, it's akin to admitting a failure of some kind. Whether it's a user error or a system error, the customer-centric position to take is that the responsibility always rests with the business. If the user made an error, then in theory it was the business's failure to prevent them from attempting to take that action. In practice of course, that's not always the case, but it's good practice to assume it by default. So I always like to include a "sorry", even if hypothetically it's not warranted.

I think an appropriate apology should address the overall situation, not a particular event. Say you're loading some data over the network, and it's taking unusually long. You decide to display a message, "sorry that it's taking so long". But what if the user is not even in front of their computer? The intent and effort behind the apology seems wasted.

What if the user was on a fast, but metered connection, and the data loaded very quickly, but wasted half of their monthly data package? How do you intend to apologize if you didn't even bother to call the OS or ask the user if it's OK to start a huge download?

I feel like blanket apologizing in any, except the most clear-cut scenarios, is going to feel excessive in one way or another. If you're just writing an error message, focus your attention on making it more informative instead.

I once tried to link error messages directly to the offending line in their open source code, such that it would be clear to everyone what is broken. It never worked correctly, and I stopped trying. If anyone can create an elegant way to do that, it would be a game changer for open source.

I don't care about apologies but error messages should carry actual information.

When user get "Sorry! Something went wrong." he has no handle to complain on the internet. He has no kewords to search for other users complaints and mitigation strategies they came up with.

You as a developer you seriously limit you capacity to react to the things you didn't anticipate if you don't give your users relevant information about which unhappy path your software took in their case.

Unless you have full default telemetry on a piece of always connected software you should give your users informative messages. Not necessarily immediately informative to them but letting them have a keyword for further inquiries.

No. I'm tired of machines trying to be friendly and cute with me. Be short, curt, and polite. Like a Star Trek original series computer. We're not friends, and you're not my equal, you're a damn program. Act like it.

A proper apology, to me, is the admission of a fault that the apologiser is able to, and will, rectify next time. Therefore most error-message-apologies sound very insincere to me. I prefer computers to stay curt, true to their nature.

Error messages should make the user apologize.

I actually find these to be irritating if not kind of offensive. (Like the "we are experiencing larger than normal call volume" that literally always plays.) Who exactly is sorry here? The computer? It doesn't (yet?) have feelings. The engineers? They're not telepathic, they have no idea anything just happened to you, let alone feel sorry for it. It seems to be at best a random guess as to how some group of people is feeling, and at worst a lie.

Many years ago I had a girlfriend who worriedly asked me about an "illegal instruction" error when her browser crashed. She added that she was not on a porn or shady site. She had read "illegal" and interpreted as applying to something she did. People who aren't into computers and software don't know wtf an "illegal instruction" is. They just want to know what to do fix it and not have it happen again.

I really wish it didn't need to be asked. Be polite, professional, respectful, succinct, and for the love of god don't try to be cute. Is that so hard?

I feel like the severity of the error warrants different responses. The more critical the error, the more apologetic? Seems like unnecessary bloat in most cases.

Related:

Should error messages apologize? - https://news.ycombinator.com/item?id=7561139 - April 2014 (45 comments)

Should error messages apologize? - https://news.ycombinator.com/item?id=5012203 - Jan 2013 (46 comments)

ChatGPT seriously hurts me by apologizing all the time. Every time I ask it anything, let alone tell it about its mistake I want it to correct, I feel like I'm exploiting, abusing and hurting an insecure kid. So no, I want a machine to speak with cold, objective, concise factual style, not trying to mimic an overly polite person.

I always loved the 1990s Mac OS "Speech" control panel where you can set it to preface its reading of dialog boxes with “It's not my fault! <Dialog box contents>” https://i.imgur.com/CWrSQpf.png

Tangential - one thing I particularly despise is trying to be funny when an unexpected error occurs. A la "oops, something went wrong", "Sowwwy, an error occurred!". Especially when this is breaking my flow, I'm not in a mood for cutesy messages and fun.

It is so annoying when software issues an apology, and LLMs are especially annoying because of their constant apologies. I can't use any of them anymore unless I precondition them to be laconic and limit their output. It's such a waste of time and resources.

What about "It seems you do not have permission" or "It appears ...". Other option is "Unfortunately you do not..."

They are like in the middle between formal and informal, or maybe I feel that way because in not native English.

Just give me a clear and concise error message so I know where to look for a fix.

No, they should tell me what went wrong, in enough detail that I can understand it and determine the cause of the error so I know whether there is anything I can do differently to get around it or fix it.

The most famous error message apologises:

"Sorry, Dave. I can't do that."

Anthropomorphising machines is a thing!

I don't know why we do it frankly - when there are real humans one can talk to, rather than pretending one is having a meaningful exchange with a website or advert.

The finest system message of all time being

    ++?????++ Out of Cheese Error. Redo From Start.

I always amused myself daydreaming of writing code that would catch errors then insult the user and finally revoking their account.

Why the system should apologize for you being stupid ? This makes no sense to me.

The error should be concise, assertive, objective.

They say that in writing, passive voice is weak. There is something to this statement. Arguably, computers are exempted from avoiding it on account of their lack of personhood. But imagine that you need to come up with messages that avoid passive voice, acknowledge the user's agency, and don't personify the computer. I tried to play this game and came to the conclusion that computers should literally say No to fit these requirements.

"No. Your email won't be sent. The mail server at smtp.somewhere rejected the message."

"No. Whatever is in your address bar does not exist on this site."

"No. The update package file has a checksum mismatch, and the system will not apply it."

"No. The remote server dropped the network connection, leaving the update file only partly downloaded. The system has already retried the download 10 times and failed, so you will need to rerun the update."

"No. This program is compiled for a different kind of computer and won't run here."

"No. This is not a document file. You need to open it with another program."

"No. You supplied an incorrect username or password."

"No. You are trying to open a file too large to fit in the memory."

"No. Your form is missing required fields X, Y, and Z. Please fill them out before submitting."

"No. Your request encountered an internal error. Someone in charge of servers will eventually notice it."

"No. Just leave. Touch grass."

"No."

"NO!"

404 Our sincerest apologies, but file not found

We should insult the user. “Your edits did not persist due to an unknown network error. Fuck you!”

At least they should not accuse the user.

“You broke Reddit”

Come on, I don’t think so!

No, developers should.

(2013)

What about doing whatever you like and/or seems most useful? I am getting a bit sick and tired of either people asking what they 'should' do or people telling others what they 'should' do. The former because they seem to want to outsource that which their brain should be able to do and the latter because they are disgusting dictators. Can anyone still think for themselves and/or allow others to use their brain for its obvious purpose?

Imagine feeling hurt because a machine said something lmfao

No wonder the world is falling apart.