> According to an intuitive semantics for 'I,' 'here' and 'now,' 'I am not here now' should always be false when uttered. But occurrences of 'I am not here now' on an answering machine seem to be true (when the speaker is not home).
(If you're interested, you can google for "answering machine paradox" for more takes on it.)
Many commenters here seem to be hostile towards philosophy. Heres a take for you:
This is only a paradox if you think of language as a way of describing some "real", static state of affairs in the world (look up " correspondence theory of truth"). There is no paradox here if we think of language as pragmatic, action directing, since it is obvious what the sentence should convey (look up "pragmatism"). Some people will argue that there is some sort of static meaning hidden behind the actual words which enters the consciousness of the listener, others will say that the meaning is only generated by the person hearing the words.
This is as philosophical of a question as it gets, and has been debated even more heatedly ever since Wittgenstein.
If you do not see that debating these questions is relevant and interesting, but would rather reduce all of philosophy to that first obvious-seeming and thus "not a real problem" position, then I wish you a good time bathing in your ignorance.
However, if you comprehend that what we take for granted in every area and discipline can be subjected to reasonable reflection, then I welcome you to the dark side. Nothing is clear, no knowledge absolute - many engineers seem to forget this while over-indulging in an overly simplistic world view :)
I think it is okay to philosophise about situations and events that seem a bit paradoxal but the explanation is obvious. Even more, that is a core trait of philosophy.
There are many similar situations where what we hear, read or see is technically incorrect. Since the sender (or the activator of an agent) of the message in such case assumes the interpreter has enough common knowledge, it is a perfectly okay communication.
A video tape containing a recording: "your watching this means I'm dead."
A secretary of a company impersonating the company when sending a message to many recipients.
An actor speaking about his character, as if they are somebody they know very well.
Writing that an AI hallucinates.
My car informing me that one of the tyres is low on pressure, even though it does not know what a tyre is, let alone how to measure pressure.
> [...] My car informing me that one of the tyres is low on pressure [...]
Thank you for putting this in a larger philosophical prospective. For I have something on the next level, a car that tells me "a tire has low pressure", but does NOT tell me which tire it is. I did the best I could to understand why my beloved car would do this, but gave up and had to interpret it as a deliberately malicious act.
My suspicions were confirmed when 1 of 4 sensors (inside the tires) had failed, and the technician read the diagnostic and proceeded directly to the tire in question. I had been desperately holding on to the remote possibility that the car really didn't know which tire has low pressure or which sensor failed, but it told the technician but not me.
I am wondering if it would be best to give the car to the technician to ensure my personal safety. How would the next aspect of this dislike manifest? Most scenarios I can think of result in the car's own suicide, but perhaps it will run me over? Please help.
Weird that tires have pressure sensors. I really thought that the control unit's logic simply averages rpm values to identify low pressure tires. I'm glad my car informs me which tire it is convinced of to suffer from 'depression'. I already checked that it identified the correct one.
Two different design philosophies: indirect (not all wheels rotating at a expected speed for current steering), or direct (wireless sensor in the tire).
Lots of linguists only work on static structures, diagramming morphosyntax and semantics of a standalone utterance. All of the fuzzy social context stuff doesn't generally get broken down into a "mathematical" structure in the same way. The piece we're missing here is called "grounding", the mapping of words in the utterance to entities in the context. I think it gets largely ignored because of this study of static structures. I don't know of any generic parsing framework/theory/tool that comes with grounding out-of-the box. It's just not done. Please prove me wrong if you know of a tool that does this. Other keywords are "deictic" and "pragmatics". Generally you only start to worry about grounding when you're doing some kind of robotics or other human-computer interaction and you need a human's words to map to sensor data or something on the screen to understand what the intention is.
As a possible exception, anaphora/cataphora resolution is pretty well-studied and for example is supported in spaCy (https://spacy.io/universe/project/neuralcoref), but this is mapping one word in an utterance to another word in the utterance, rather than to an entity in the context.
This is ludicrous. Failure to distinguish the person (“I”) from their recorded voice does not make a philosophical problem. It's pure and unadulterated stupidity.
I find that the joy many commenters here have in both denigrating philosophys and at the same time proudly demonstrating no interest in knowing anything about it to be one of the more embarrassing things regularly on display.
I wouldn't call myself a philosphy expert by any means (love me some Epicurus) but I think the previous commenter is right. As far as philosophical dilemmas go, the answering machine problem is contrived at best.
It relies on a pretty obvious mischaracterization of the situation at hand - there isn't a person saying "I am not here" at all, it's a machine playing a recording. With the necessary context, the dilemma becomes a pretty obvious non-dilemma.
If you're saying we should be willing to explore our minds through philosophical problems, I agree with you. I just think this particular philosophical problem is pretty lame.
Is the conclusion supposed to be that that formal meaning of any particular word is less important than the ability to communicate abstract ideas? That's an interesting notion though I'd argue that notion isn't helped by a half-broken analogy.
"Paradox" and "dilemma" and even "problem" don't have as strong a meaning in philosophy as they do in colloquial English. In this context, the claim is essentially that a particular system of analyzing the truth of statements will incorrectly analyze this particular type of statement. The "paradox" is in the system, not in reality. The paper linked offers a solution for modifying one particular system so that it will correctly resolve the paradox.
The programming analogy would be that processing a particular type of data will often have hidden pitfalls for the most intuitive approach. It might be easy to avoid those pitfalls by modifying your program, but someone had to notice and document the problem and the workaround.
In that case, let me go a step further: although I wouldn't respond the way some other folks have, I get why they would. Many of my most memorable and most intellectually stimulating classes were those that weren't related to my engineering degree. The philosophy classes, though, never even approached "intellectually stimulating" status. I wrote a good 80-100 pages of pseudointellectual drivel about half-baked analogies like the "answering machine paradox," and accrued thousands in debt in the process.
Another thing: The great thing about Philosophy is that there are no wrong answers. But, the bad thing about philosophy classes is there are wrong answers. Open-endedness and free thinking don't scale to 150-seat lecture halls, indifferent TAs, and PhD-candidate "professors" doing the bare minimum to get a diploma.
Oh "anything about it" isn't quite valid, now is it. We see gibberish with nonsensical blather thrown in, and zero logical reasoning behind it. It's not a science.
If you want to tell me it's akin to astrology, or some other pseudo made up framework, fine.
I don't have a problem with fantasy. I have a problem with those telling me it's real.
"I took a series of university classes, where we examined the natural laws in The Land, and Thomas Covenant's ring, and derived a measure of predictive weather patterns! I know science!" <-- philosophy
The term "scientific method" is itself a philosophical term (as is "method" in this context). Read, or even skim, this and notice how many of the important figures listed were philosophers:
No, my argument is that you lack even a rudimentary understanding what it is all about. You only need some curiosity and an open mind to get that. I’m certain there are something in Wikipedia that can help.
Philosophy is not and does not purport to be a 'science'. The fact that philosophers make and discuss propositions that seem incorrect to you does not mean that the field of philosophy is fraudulent or unimportant.
Do you think that mathematicians are drama queens because "2a = 4, solve for a" is a "math problem"? Just because something is intuitively simple doesn't mean that you don't have to account for it in a formal system. The intuitive solution for a lot of simple questions is incorrect in some cases. (How do you determine the length of a word?)
In your example, "here" is semantically different from the "here" in the answering machine case and doesn't result in a paradox.
You probably haven't thought deeply about the problems. Usually they expose some issue with our concepts or assumptions. Things we take to be obvious and simple aren't always on careful reflection.
On the one hand, these puzzles often arise as counter-examples to a theory within analytical philosophy, and unless you understand what they are a counter-example to, they seem pointless and even ridiculous. For example, when Russell posed his famous paradox to Frege, he was not trying to find out who shaves the barber.
On the other hand, perhaps we should consider whether analytical philosophy, following the linguistic turn [1], is creating problems for itself when it tries to find metaphysical truth by analyzing human language as if it were a formal system. For example, when David Chalmers says "even God could not create a male vixen", is he mistaking an accidental lexicographical fact for a metaphysical insight?
This may be true, but if it is the canadian journal of philosophy is doing their reputation no favors by publishing the "answering machine paradox". Paradox. Paradox. That's a funny word, isn't it? Paradox.
No, that's pretty much what the word "paradox" used to mean, but logicians of the late XIX–early XX century had hijacked it.
PARADOX, in philoſophy, a propoſition ſeemingly abſurd,
as being contrary to to ſome received opinion, but yet true
in fact.
No ſcience abounds more with paradoxes than geome-
try: thus, that a right line ſhould continually approach
to the hyperbola, and yet never reach it, is a true para-
dox; and in the ſame manner, a ſpiral may continually
approach to the point, and yet not reach it, in any number
of revolutions, however great.
Encyclopaedia Brittanica, 1771,
Vol. 3, p. 455
I was being glib, of course. Presumably there's some legitimate technical philosophical issue, and actual philosophers are capable of using answering machines and even landline telephones without having all their assumptions about reality collapse around them like a PKD novel (those born prior to 1980, anyway). But, like Jay Z, I've got problems of a more pressing nature, and legitimately don't see how this matters.
(See also the 'Problem' of Induction, which I had to spend a great deal of time on in college, and even after reading centuries of debate about it, is the least problematic 'problem' I've ever encountered. Maybe this is a linguistic issue, and philosophers should stop calling things 'problems' when the rest of us have to make rent.)
The implication here seems to be that people can't think about and discuss philosophical problems and also take care of more immediate physical concerns at the same time. Do you feel that way about other intellectual endeavors without immediate applications, like "pure" science and mathematics?
I wouldn't say so. If we mark this a stupidity, then a lier's paradox is a stupidity also. If people could easily deal with such statements and understand them correctly, it doesn't mean there is no problem. Problem arises when you try to devise some formal system describing all the statements, and then you find some more statements and the system doesn't work for them.
Zeno's paradoxes for example show us the weaknesses of Ancient Greek's system of reasoning, the weaknesses of their kid of logic and math. But will have troubles seeing them as paradoxes if they do not know logic at all or if they know modern logic and modern math which solve all of the Zeno's paradoxes (or most of them?). Now Zeno's paradoxes are not paradoxes at all, but the silly mistakes of reasoning.
It reminds me of edge-cases in programming, you designed a beautiful program and then edge-cases started to pop up, you patch your program, patch it some more, and in no time at all your beautiful program becomes a heap of spaghetti code. The only way to avoid it is to code something that you coded before many times and know all the shenanigans allowing you to combine beautiful design with the practical applicability.
Here is the same thing, if you do not know what the system the author uses, you cannot judge if his reasoning stupid or not.
I don't know either, but I believe, that it is an interesting observation. The person said "I'm not here now", and it was obviously false, when they said it, but when answering machine says it the statements becomes true. I'm not sure what the problem is, but I think, that the problem starts biting you hard, when you try to define a set of all such statements and to choose a condition of their truthfulness. Of course, you can use your intuition as a tool for demarcation, but philosophy doesn't work that way, it seeks an objective criteria, preferably a formal one.
Absolutely off topic, but does remind me of a Mexican movie ‘I Am No Longer Here’ that I’d seen not long ago was astonishingly good for something I hadn’t heard of.
Computers can stop time because they don’t have to execute instructions. In a sense this is an example of what that affords.
Think of a physical message on a piece of paper. The paper is on fire. You can still see the text, but it’s too late to put out the fire.
If you have good memory, you can figuratively stop time at that instant and memorize the contents of the paper. With a computer, the message is already “burned” on the server, but the frozen instant in front of you can be extended indefinitely.
As with race conditions, making things faster doesn't change things but only exposes preexisting problems. The preexisting problem I see here is sloppy definition of existence for the message: if you can see the message on a burning piece of paper, it should be considered to still exist (just as a message being sent with smoke signals does not disappear the moment it's committed to smoke).
E: The obvious way to fix this is to stop talking about messages existing/not existing, but talk in terms of messages being stored in X (or having been deleted from X), for some value of X.
It’s not the word “exists” that causes the problem (although it definitely gives it an added air of strange mystery). It’s the word “this.” Consider the case of a draft email I am writing on my laptop, but have to leave before finishing. Later, I resume composing the email on my phone and I hit send. But I do it in a hurry and mostly forget about it. The next morning, though, I open my laptop and I see the still unfinished draft I left there.
Now, when I try to finish and send that I’m hopefully going to get an error message. But “you already sent this email” is both right and wrong, since “this” email (the one I’m looking at) may have different contents from the one I sent.
Agreed that the best error message is just more precise though: “You are attempting to edit a draft that you already finished and sent from another device. Would you like to treat this as a new email?” Or something like that.
It used to be so during the golden age of personal computers or if you run Linux and have tweaked it so. But modern-day operating systems will bend the nature of reality itself if they have to, in order to restart and install updates, or to force you to change your password which is already 120 seconds old, or to log you out for security reasons if you stop moving the mouse. You better save that message promptly.
The problem is that the message does not speak the truth. If you can read a message it clearly must exist because you cannot read non-existent messages, can you? Can anyone? CAN ANYONE HERE READ NON-EXISTENT MESSAGES?
The message should have said "This message is not saved on the server. If you close this window without copying and saving its text you cannot retrieve it from the server ever again.
You might argue that 'not existing' in general does not even exist.
It reminds me of the ted ex talk where a man states that the universe does not exist because it is everything and if we would make a list of everything, the list would not be included as a topic of the list.
While this is the most sane and logical sounding way to put it, it would lose the 'philosophical' vagueness of the original notification. I still prefer the original wording
Of course you can read non-existent messages, for example when an AI hallucinates one, or when someone shows you a photoshopped screenshot of one, or even just when you copied one to a text document before deleting the message.
No, it’s a citation of a message that does not exist. I wasn’t talking about a message sent by an AI, I was talking about an AI reproducing the alledged content of a purported message.
If you open a text file in an editor, and then delete the file on disk, then the file does not exist anymore, but you can still read its contents in your editor. Same if you open a web page in your browser, and the page is then deleted server-side. You can still read the loaded copy of the web page in your browser, although the web page doesn’t exist anymore. The “message” in TFA’s notification is exactly like that.
It depends on how we define what we mean by the word "message".
In the common sense interpretation "file" is not a "message". Nor is the display on which you are reading the message. Nor is a clay-tablet on which ancient Sumerians wrote messages.
"Message" is information sent by someone to someone else. A message could be saved in a file but then the file is just the "medium" for transferring the message to its future readers.
So I would think that "This message does not exist" is something like writing "This is not a pipe" on a painting of a pipe.
I never understood what Marshall McLuhan meant with "Medium is the message". Medium is what makes it possible to transmit messages. Can anybody help me out, what did McLuhan mean?
This message means something analogous to: “You loaded a file, but now the file doesn’t exist anymore (on disk), so I can’t update it with your changes. You can discard the loaded copy, but consider copying its contents first and create a new file from it, because for some technical reason I can’t do this myself.”
Oh, finally a chance to put my Philosophy degree to use!
The error says the "message" does not exist, but the message is not the same as the text. The message is an object that can be saved or discarded, and it contains text.
The text still exists and can be copied, but the message is gone and can't be saved anymore.
The author addresses this though. He calls it the contents instead of the text but it's the same thing.
> We learn a final affordance, which complicates the story. An inexistent message has contents, which may be copied – but only if the message has not yet been discarded.
The message is gone and can't be saved anymore, but it can still be discarded (or presumably not discarded).
It's still funny that the text of a message can exist without being a message itself. That must make sense in the specific context of Outlook, but it shows that the conceptual design of the software does not match how we want to think about the domain abstractly.
I would assume Outlook means that its locally-cached copy of the message exists, but the original server-side (probably IMAP) message no longer exists. And that without that message, there's no server-side resource to update — just a resource representation of a snapshot of that server-side resource, still temporarily persisted in a client-side read-through cache.
> the original server-side (probably IMAP) message no longer exists.
Doesn't Outlook rely on the Exchange mailstore?
It's a long time since I was near to Outlook and Exchange, but I thought the Exchange mailstore was some kind of X400 abomination, and that the IMAP capability was a bolt-on.
This letter cannot be read because it has been burnt to ash. You can only throw away the ashes. Make sure you read the letter and retain the contents in your mind, before you throw away the ashes, if you want to use them later.
Like people who’s bodies are gone but who’s souls are still here? I see dead messages… :P
That distinction might be worthwhile, and it’s certainly true from a technical standpoint. But the real problem here is the message is not the same as the message. If that was referring to a single message it’d make a great philosophical problem. Unfortunately we’re just talking about a more boring problem of two different messages with two different texts where the text of one of them accidentally referred to the other one as ‘this’.
> if the message never achieved a physical form such as printing, does the message exist?
The physical bits do exist, though, on the storage medium. Now, of course this does not match our usual image of existing, since the bytes were technically always there, but it still exists in the physical world.
You can actually make the same argument with a letter: The paper and ink were there before, the pattern ist what brought it to existence.
>if the message stopped existing, but nobody was there, did it make the trash-can sound?
I know the answer for the case where this question refers to something on my pc. I have disabled audio warnings, alerts, etc so if the message stopped existing and I wasn't around to notice then it clearly does not make a trash-can sound.
What substantial difference is there between a message being manifested physically via printing as opposed to having it be a collection of bits in specific states on your hard drive (or memory, for that matter)?
In what way are magnetic patterns unsubstantial? You can read information from them, which is really what we’re trying to do here, isn’t it?
Is the goal to have it be readable to the naked, nominally working human eye? If so then I’d wager you could use magnetic paper as storage if you were a particularly persistent driver developer.
"the message does not exist in our system, only in your browser as text, copy and save it if you want to keep it, if you refresh this page the text will disappear"
Example: You are editing a table row with some application, but when you try to save the changes, the system discovered that the row has been deleted from the table. The business logic does not permit you to create rows arbitrarily, so a new row cannot be inserted instead of updating existing one.
The behavior admittedly does not make sense for files (although I suppose you could rename or delete the directory that contains it), but it's sort of unavoidable if you don't want to take locks while some client application you don't control may or may not make changes.
The sane will tell you that Necronomicon doesn't exist in our world, yet we have a vague idea of what it contains and we're sure that it contains only the most repulsive of things.
The message object used to contain those contents, but then the message object was deleted, although the contents value was still available in a UI in temporary memory.
Everyone is snickering at this and talking about philosophy, but there is actually a legitimate point being made here, albeit obliquely: how do you explain to a non-technical user that their data has been deleted on the server, but that their client still has a cached copy that they might want to try to salvage somehow? I submit that this is a nontrivial problem worthy of serious consideration.
> how do you explain to a non-technical user that their data has been deleted on the server, but that their client still has a cached copy that they might want to try to salvage somehow?
How about: "This message has been deleted from the mail server, but Outlook still has it in its temporary cache on this device. You can copy the message contents, or discard it from the cache, at which point it will be permanently deleted."
this is the only correct answer. "a non-technical user has no idea what a server or cache is" sure, but they can learn. The average person is much smarter than you think they are (when it comes to matters that actually affect their day to day life). If they don't get your explanation, it's almost always because (1) they don't care, they don't see why it matters to them (it often doesn't) (2) you're not explaining it well enough
feynman has a nice philosophy on this that I think is true & useful: (that there's great variety in capability of the average person, we should explain things faithfully & without dumbing it down):
The problem is that people's brains just fucking shut down once it's computer related. "What was the error message?" "Idk I didn't read it." "Well here it is, it's asking for your password." "Ok what should I do?" This type of shit is more common than it should be. So many people just give up on computer related things that isn't the happy path.
If those users aren't reading the error dialogs anyways, why do the error dialogs need to pander to those users? I wonder if the "make it dumb enough for every user to understand" approach leads to user comprehension plateauing prematurely.
Shareholder-driven growth targets mean it's no longer good enough to target the 20th percentile users, who might have reading comprehension at a 5th grade level. You have to hit the 10th percentile, or the 5th. Be glad that you still get text instead of pictures.
> Be glad that you still get text instead of pictures.
Even that isn’t a given. I’ve seen banks using emoji in their notifications. Companies are using ML to predict which emoji to change your text to. There are emoji domain names. Etcetera.
Tangentially related, I used to work at a company where the C level was demanding all of our help documents be videos. They couldn't understand that it made them unsearchable, took way more time, did not allow branching or decision making in the processes, if anything in the workflow or even UI changed the entire thing would need to be redone, takes up a ton of space, is not easily skimmable etc. "but it's easier than reading!" "are you telling me you've never learned how to do things on YouTube?" Etc. I refused and resigned not long after.
I was thinking you could do product demos / help videos combined as an acceptance test suite.
You would programmatically build the self help tutorial like a ui test (use a test browser and it would be like cypress/selenium). You would write a script, (ai) text to speech, and you could even respond to user input for branching.
These would be, de facto, your acceptance test suite and your tutorials will flag when they break on new ui developments, helping to keep them up to date
Counterpoint, when a random dialog asks for a password, the answer is not always "give the password", so maybe that's part of the reason why people find it so confusing.
I'm glad you said this because Feynman has a beautiful response to it: basically, there is no such thing as a "non-technical user". Almost everyone is adept at navigating _some_ complex system in their life. I agree with you that they probably don't want to learn.
but the reason they don't want to learn is because they don't think there is any value on it, they believe it is a waste of time. For the same reason I (used to) believe it's a waste of time for me to play puzzle games (I'm bad at it, I don't enjoy it, what's the point). Or learn to manage people, or learn to understand politics, etc.
I'm asking you (and everyone reading this) to suspend disbelief and pretend that these users DO have capacity to learn, and they just don't see any value in it, and it's on us to clearly (and concisely) communicate the value without gatekeeping and without dumbing it down. I have been surprised at how people's capacity to learn was much greater than I expected, and I hope the same will be true for you.
I see this attitude a lot of, "well, if you want to understand how this system works, we have to start from scratch" (and they start to lecture for hours about some fundamental things). I think this is a failure mode: an inability to figure out _what_ fundamental pieces actually matter to understanding the current system.
Apologies for the rant, I feel strongly about this because I think there's a lot of low hanging fruit here that everyone can benefit from, but I'm still trying to refine my thoughts.
A typical person's head will explode at the mention of the words "cache" and "server". They will then go into a blind panic that their data is going to be "permanently deleted".
Yeah you can't use words like that. Even many people who won't panic at the word "server" don't really understand what it is.
"This message no longer exists in your Inbox. If you close it, you will not be able to open it again."
What's more amazing is that this state actually happens often enough in Outlook that somebody wrote code to detect it, and to create a message box for the user to warn them about it.
This is stupid, and you are stupid to entertain this idiotic notion.
Let's take another example:
"The mobility device can no longer operate. Your destination is no longer available."
This tells me absolutely nothing. It possibly even implies that something very bad has happened to my destination!
"The bus engine has broken down. Your route destination is no longer in service."
Even to someone who doesn't know what a "bus", "engine", or a "route" are, this is an actionable and clear message. If I don't know what those things are, I can quickly figure out what a bus, engine and route are, or pass the message to someone who does understand.
Removing information and replacing it with nonsense does not make an error message better. You don't need to be technical to be able to make sense of a message.
So what? Most users will understand this or at least get the gist. My mum can ask me what it means and then I can tell her. That's a much better outcome than the original message.
I'd say a non-tech user has no idea what a server or cache is. I'd go with the word "backup" instead. Something like telling them that email is not backed up (online? where?) and if they delete it from their computer it won't be able to be recovered.
Does anyone have any real studies about whether users will "have their heads explode" when presented with technical language? Apple and Microsoft did user studies for this sort of thing in the 80s and 90s, right? Has anyone done similar in the 00s, 10s, and 20s?
There are only two acceptable solutions to this problem:
1. No error message. Just recover the cached message.
2. The message is deleted
There’s a world we live in where ahem-ahem a certain design focused company would’ve done it this way.
Ultimately, it’s the responsibility of the Mail app to make a decision on whether to recover the cached message or not. It’s those engineers & designers who built that damn cache in the first place. And the server too.
Let _them_ deal with the consequences of messages existing in one but not the other. It’s not the user’s job to care.
Funny of you to think your non-technical uncle is aware that there is such a thing as "mail server". All they know is that this email thing works, in the sense that he can send and receive emails.
Some good passes at UX copy in this thread, but for this application, I’d recommend against trying to explain the underlying technical mechanism at play and instead frame it in terms of outcomes.
“This message has been deleted, but you still have a temporary copy. If you need to save anything from it, you should do so before discarding the temporary copy.”
This is the best one so far. Combine that with the 'if you refresh this page the text will disappear' from another poster and I think we have a very workable error message that outlines the issue, solution, and due caution necessary, for the potentially non-technical user.
You don't. Explaining what happened is not going to help the user at all. You can only explain what options are available to the user. Something like the following
"Sorry, this message can no longer be saved. Copy this message before discarding it if you will need access to it later."
Sorry but hard disagree on this one. This increasingly popular assumption that users are clueless cavemen is very condescending. Help the user self diagnose instead.
WHY can’t it be saved?
Is the internet not connected? Check your WiFi.
Is the server full? Talk to admin.
Is the message deleted by another user? Talk to your team about ways of working?
Is it an internal application error? Tough luck, maybe the error code can be googled at least.
This does not mean you need to dump a stack trace in the users face, the examples above can still be presented briefly. If that’s too much effort to implement, consider an expandable details section.
The amount of applications lately where I had to open the verbose developer logs only to find silly user fixable errors is astonishing. Last one was simply credentials that had expired.
To anyone who thinks you are giving the users a magical experience, free from technicalities, by hiding root causes behind a facade of abstract, please think again. You are just frustrating the users even more, by making errors unpredictable.
> This increasingly popular assumption that users are clueless cavemen is very condescending.
Sorry, but no. And this idea that everyone else is condescending is offensive nonsense.
I understand where you're coming from, but the people who understand how actual users behave and what actual users want, in the real world, are not condescending - they're empathic. They recognize that the majority of people in the world are not like us, in terms of technical abilities, yes, but more importantly, in terms of desires.
The average user doesn't care. They don't have time to do things like "talk to admin", nor do they even know what "check your wifi" means. "Talk to your team about ways of working"? I'm sure most employees would just love to go and have awkward conversations with others, that's exactly what they want to do this minute.
This is even on the off-chance that the user has even read the message, which is incredibly unlikely. I can't count the number of times I've had developers tell me they had an error message and don't know what to do, and my solution was "let's read it, it says this is the error" and that being revelatory for them.
> This is even on the off-chance that the user has even read the message, which is incredibly unlikely. I can't count the number of times I've had developers tell me they had an error message and don't know what to do, and my solution was "let's read it, it says this is the error" and that being revelatory for them.
I agree that the problem with technical and non-technical users alike is one of motivation. Like you say, someone who is not technically minded won't care that the server is out of pace or their wifi is disconnected and developers who just want to get their code to compile don't care about learning how some new framework works.
But in all these cases, the users do care about doing whatever they were trying to do when they got the error. And the best way to help them is to give them all the relevant information they or someone else needs to fix it. Giving some generic error like "sorry your file could not be saved" neither helps those who are motivated to fix it, nor those who aren't motivated.
I find most apps give up an enumerating the possibly modes of consistency violation that can occur in an app. I’ve tried and failed to do it “right” before and it’s incredibly difficult.
Yes, let’s try to explain technical things to non technical people without using technical words and pretend we're getting somewhere and that it's useful for them.
> how do you explain to a non-technical user that their data has been deleted on the server, but that their client still has a cached copy that they might want to try to salvage somehow?
“The message has been deleted, but your app still shows it. You will not be able to see the message again if you discard it, and it will disappear soon.”
That's why you always have people to either copy-paste error messages or send screenshots. Because people are terrible at reading and even worse at reproducing what they read.
The developer doesn’t know what went wrong and things definitely don’t go wrong all the time at Microsoft! This is as surprising to the developer as it is to you!
It’s also pleasantly humane, not like “ERROR:”, meaning it’s more of a silly and fun oopsie doopsie than a systems engineering failure.
Don’t you just feel better as the user seeing that? It’s not the systems engineer’s fault and neither is it yours. It just kind of happened. What even is “it”? No one knows! Computers are weird — eh? Nothing like a whimsical hiccup in your computing to brighten the day.
Whatever you were doing, whether it’s saving work, buying something, or completing critical forms, some of that was probably done, or maybe not, but who really knows? Hehe, not us — we are just as surprised!
Oh, and don’t call support with this stuff. There’s not enough to go on even if you reported it for us to investigate. It’s just one of these things, you know?
Forget about it and move on buddy! You’ve got an essay to rewrite/a purchase to figure out/a critical form to complete again, and who knows what will happen then! Will it go through? Maybe, maybe not. It will be surprising if it doesn’t! Isn’t it just so exciting?
Damn straight. This came up in an earlier discussion about languages that rely heavily on exceptions - they sensibly don't want to expose backtraces so you get this `try: response_handler() except: print("oops!")` nonsense because the programmer literally doesn't know what went wrong and they're sure as hell not going to give you the details.
More microsoft would be a 5 minute message on screen promising that they have never and will never misplace any of your messages, right before this monstrosity appears
I've had similar philosophical thoughts about a transaction rollback.
Consider this definition from go's database/sql package.
func (tx *Tx) Rollback() error
Rollback can fail, indicated as such by it can return an error. What are the cases where rollback could fail and what's the recovery mechanism? Does a failed rollback mean (logically) that the transaction is still open and uncommitted? But really, invoking rollback can never fail to abort the transaction, so the error result has little use.
Now, obviously the error isn't totally useless as an error can be returned to indicate, say, the connection to the database was dropped. But even in that case, the definition of a transaction's validity/lifetime means that even if rollback fails, the transaction is in the same state as if rollback had succeeded.
Pending and rolled back are different transaction states. The former uses resources and locks and can prevent other transactions from happening.
Rolling back a transaction twice probably indicates an error in your program, which Go's API is giving you a chance to report to yourself.
Ultimately every network request can fail because of the Two Generals' Problem. Actually, every single operation on a computer can fail (as in, do something other than what you were promised or promised yourself it would do). Nothing in life is guaranteed, the environment is adversarial. The fact that we create machines that can be predicted with 0.00000000001% certainty and carve out a safe environment for them and feed them energy is not common and unnatural and all computers will also eventually succumb to entropy. The network is just where that is common enough that considering that another computer can die in our programs can be more useful than completely ignoring the possibility. This possibility is represented as a non-zero number called "error" in the Go API you've posted, so that you have the option of branching your program to a different execution path if the database you're communicating with stops existing or at least stops being reachable.
This is correct - Sleep(1) does sleep for approximately 1 second; the problem is you're confusing the 95% confidence interval (which might be as narrow as (999ms,1001ms) for some reasonable designs) with the absolute error bounds (which are (0ms,∞ms], and yes, the infinity end is inclusive).
If your software is running on a VM, and that VM is suspended (e.g. for migration), the end of sleep could be minutes or months in future.
This is surprisingly common when running on certain VM instance types on public cloud! Common enough that I've had to account for it in production code.
The confidence interval comment still applies for any production or client environment I've ever deployed code to.
Unless you actually expect your environment to spend more than 5% of its time on average getting suspended and resumed. Maybe you work on some tooling that is scheduled to run right around migration time (for servers) or sleep/resume time (for clients).
"Approximately 1 second" is fine. You just have to keep in mind that other influences can block your program from running. Those other influences can trigger even if you don't sleep!
>Does a failed rollback mean (logically) that the transaction is still open and uncommitted?
Yes, it means exactly that until something else manages to close the transaction.
Generally that's done by noticing that the connection has failed, or a timeout has expired, assuming "roll back unless confirmed" is the default behavior (usually true, but not always).
The reason you might want to explicitly tell something to roll back is to shorten ^ that latency, or to wait for it to complete before doing something else that requires it to be gone.
Or the Java SQL connection interface, that can throw SQLException on close(). Yes, if your connection throws an error when closing, I guess it stops being usable.
Has anybody ever did something useful with that exception?
Depending on the durability guarantees of the database/connection in question and whether it uses request pipelining, I could imagine it indicating something like "non-clean connection shutdown; your last few commands might not have been processed"?
There's a similar situation in raw socket programming in some OSes: You might be done writing all your outbound data into the socket (i.e. your last write() call returned indicating success), but the receiving application might crash before being able to read all of your data.
By implementing an application-level shutdown command that the other side acknowledges, that can be avoided; maybe some SQL protocol implementations do that, and that exception is thrown if the shutdown request is never acknowledged.
I've seen this happen in Oracle using two phase commit, when the transaction coordinator drops dead before transmitting a commit or rollback decision. The transaction remained in doubt for months before someone noticed.
You can ask around and manually coordinate a decision, and tell the databasecwhat you decided.
Oh that's interesting, and probably manifests a bunch of issues related to storage and rollback segments being consumed with the transaction staying open for months.
But that's not the same thing as rollback failing (although it is the invocation of rollback failing) as neither rollback nor commit was fully issued and received, so it makes sense that the transaction would stay open (given that the database doesn't tie transactions to the a connection or a session, and for a two phase commit scenario I'd expect the transaction coordinator to "own" the transaction so it's lifetime isn't necessary tied to a session).
Yeah, the story is a bit incomplete. The full chain was application->transaction master -> 20 or so slave databases. It was a weekly batch dispatching data to the 20 slaves, starting with a full delete of each slave.
Someone decided to literally pull the plug and replace the master database server node from the rack, while the batch was still running. He assumed the other server nodes would pick up where this one left off. So the batch log of the application first complained about the master disappearing, then about the rollback failing on another master node because it wasn't the coordinator and had no idea of this transaction.
It also means the decision about the commit/rollback was irrelevant, as next week's batch run had deleted the records in question. Presumably, some ephemeral records were hanging around, deciding if they were deleted either in week X or week X+1.
Remands me of "Operation failed successfully" errors. It was a meme, but in some cases I had to implement failing an operation in a test service fake and log something like that.
Not exactly the same but an engineer I was working with wasn't handling a failure case properly and leaving transactions open. It was reported that the DB would stop working after a certain amount of time. I knew transactions were hanging but I didn't understand why. I sat down with the engineer and QA trying to figure out the problem for well over a day. QA was running their test suite over and over. We started removing pieces one at a time until we found the problem.
I don't think that "leave dangling locks" is obviously a possibility from rollback failing. What's the method to clean up those locks? Rollback harder? Commit? If a transaction is ever aborted and there's a chance that locks specific to the transaction (MVCC locks necessary for transactional semantics) are still held then it would be safest to always issue this mythical "clean up locks" statement after every rollback attempt.
The default final state of a transaction that is not explicitly committed (and even autocommit is still explicit) is that it is aborted, purely because the only way a transaction can be committed is by commiting it vs there are an infinite number of ways and reasons for the transactions to abort. If the rollback is successful or not there is logically no way that the state of the transaction after rollback being invoked is that the transaction is still usable for something.
The bug being referred to isn't the connection problem, the bug is that in the event of a loss of communication with the client, the transaction isn't fully cleaned up, including the release of held locks, when the transaction enters an abortive state.
It often takes minutes to hours for a connection to be reset when one of its sides went away. So no, it's quite often that one side will get these exceptions while the other one is locked up for prolonged period of time.
You could argue from the perspective of the server this is a true statement. The message does not exist. If the server stored a history of messages, current and deleted, it would not be in the logs. What you received is something different. Like a message but not a message.
I do not think you need a philosophical degree to handle this. A law degree is enough. Just add “legally” before “exist” and everything makes its perfect legal sense again.
Indeed, since this person… I mean message - is not in the list of ones legally allowed to exist, you can’t hire it, can’t fire it, the only thing you can do with it legally - is to kill it. But that does not prevent you from searching its pockets first and making use of its valuables.
Isn't all of this just equivalent to a pointer? "This variable doesn't exist" is a reasonable error message when you're, for example, dereferencing a pointer with a wrong data type: it could be the equivalent of "there's no integer at this address" or "this integer doesn't exist".
The problematic "this" is just an indexical in that case, and it works fine in terms of ontology, just like we might say "this house doesn't exist", while pointing at a burned up lot. Any fluent speaker of English will understand that, just like how they'd understand a description of the Parthenon as "this is a great temple", while looking at a ruin.
"This email doesn't exist" is not really problematic; the metadata persists but the body and subject have been deleted, plus whatever else constitutes "a message" in this schema. We can refer to it, because the pointers still exist, but the value at the address is gone.
The house might not exist anymore, but the address still does.
Your pointer scenario could have the same warning, but it does not match the scenario in the post. In the post, we have """the message""" displayed on screen. It's not a simple dangling pointer, the contents are right there.
We're standing inside the living room while saying the house doesn't exist. And as soon as we walk out the living room will disappear.
I'm sorry, I miss things nowadays, but I don't see where the post states that the message is still available.
If it is, that's probably a desync issue, like others have said. Still not particularly mysterious or ontologically interesting. So much of parallel and distributed programming is about solving desync problems.
> I'm sorry, I miss things nowadays, but I don't see where the post states that the message is still available.
I put it in super scare quotes for a reason, because it depends on what you mean by "message".
But the text is still on the screen. That's why you can copy it.
> If it is, that's probably a desync issue, like others have said. Still not particularly mysterious or ontologically interesting. So much of parallel and distributed programming is about solving desync problems.
If it's just a desync, then it could resync things if it wanted to. Instead it gives a confusing and contradictory warning.
The way the warning contradicts itself is pretty interesting, and I and the author think it's fun to delve into how the word "message" is supposed to be defined here, and how it's causing problems.
But it's not simply a reference to a thing that's gone. It's not actually gone yet. It's a ghost.
Yeah, I said "the equivalent of a pointer" because it was an analogy. I then spent the rest of the post trying to cash-in that analogy. Sorry I wasn't clear enough.
> A returned value of 1 seems to say, "I'm here, but you can't use me."
> Strange as it may seem, that's exactly what is going on. A return code of 1
> means we're not allowed to install the print spooler because interrupt 47
> is being used for some other purpose by some other interrupt handler. This
> is a fascinating bit of business to contemplate.
This is typical Microsoft logic. And 'logic' should be quoted, because Microsoft has the most stupid texts in their products. They make translation errors, grammatical errors, use incomprehensible and stupid comments.
Currently working in a Microsoft-enabled corp with a very aggressive document retention (i.e. deletion) policy. This message doesn't surprise me at all. Stuff just...disappears. All the time.
Exchange did this thing well before there were any practical LLMs. And well, while the resulting state and error message is somewhat hilarious, it is not that hard to trigger this behavior intentionally.
While the warning may seem
obtuse, it’s obviously referring to a message in a state of limbo. It exists in some kind of cache (and therefore only locally) but all traces of it have been deleted on the remote storage. It actually makes sense to me, and I think MS handled this edge case very well. I actually cannot think of a better way to handle it.
I suspect it means the message only exists client side, and they are able to detect that somehow. So if you browse away, or refresh, or whatever, it is gone.
If we placed a giant sign around Earth stating, 'This planet does not exist,' and considering that Earth will not survive the Sun's demise in 5 billion years, would it be a paradox for aliens in galaxy GN-z11, located 13.4 billion light-years away, to observe this sign?
That would probably allow inserting any message you want into history. Malicious messages too. "Your honor, server chat history shows that the defendant indeed sent that explicit message to my client". Inserting on server messages sent to you seems pretty crazy idea for anyone who ever programmed any chat functionality.
Why does the author find this so difficult to understand? I read the error and both immediately know what the problem is, and can guess a likely series of events that caused it.
1. You load a page with the message, and your client (browser) renders its contents after fetching it from the server with an API call
2. Some unrelated process causes the message to be deleted on the server
3. Some asynchronous process on the client (like a periodic refresh) tries to get the message, but it's since been deleted, but the client-side rendered state stays the same
4. Thus the error: the message doesn't exist anymore, so you can discard it to manually make your browser state consistent with the server. Or you can just refresh and it'll be gone. So if you want to save the contents, copy it in your clipboard first, before refreshing.
Reminds me of a joke where a Jewish kid asks his dad “what’s the holy trinity?” And the dad replies, “there’s only one God and in this house we don’t believe in him.”
I was expecting this would be another version of This X does not exist (where X is a cat, person, molecule, etc.) where generative AI has been trained on messages and gives a plausible message that has never been given before.
Leave it to Microsoft to come up with nonsensical stuff, be it names or something like this. They must have an ample supply of specialists for braindead language.
Outlook is server authoritative.
Message does not exist on server and thus it can't be saved.
But it is available on that client - client was able to load it before it was removed from server - and such it can be copied out or discarded from client.
"This message does not exist" can be taken to be a false statement, without introducing any contradiction.
It is not like "this message is false" (Liar's Paradox) or "this sentence has no proof" (Gödel's sentence).
Unfortunately, just because "this message does not exist" is a false statement, contradicted by existential evidence, doesn't mean that the remaining claims next to it can be dismissed as false.
Perhaps not, but if one encounters a false statement, then it is reasonable to assume any following (and previous) statements are suspect as well.
Also I think you are missing the point. This is clearly written tongue-in-cheek. The author is being entirely rhetorical; they're not asking you to solve the apparent inconsistency. They just thought the error message was silly, and that working through it logically (as if each statement in the error message is true and correct) is a funny exercise.
The statement has a true interpretation. "This message" can be interpreted as referring to some object in a back-end database represented by text you see in the UI. The thing you see on the screen corresponds to no persistent representation in the system.
"This person does not exist" under an AI-generated image similarly tells the truth; the image is not the person.
I've gotten this message and it kind of illustrates one of the many aspect as to why web-browser apps are so terrible, that the storage is disconnected from the app and the connection is unreliable (and in most cases (if not on mobile) it is just that the server is unreliable, because it has to handle 10 million other connections).
> Make sure you copy the contents of the message before you discard if you want to use them later.
Like, really? Is that the best you can do? You rely on a human to copy-paste text because you can not be bothered to create it yourself?
In theory, yes, that might be the best they can do because they can't connect to the server - in my case however, that was not the case. Outlook worked fine and I got new notifications, but I had to manually preserve the content.
It's been 20 years since gmail "disrupted" webmail, yet it still sucks. At best they only give the illusion of search, because they don't have the resources to do it properly. How people can stand it is beyond me.
It is much worse than that because a proper client can have storage as well. The key difference is that the browser is not a proper client but a general purpose interpreter and that webb applications don't have a choice no matter how bad of a fit it is.
But it can't trust the storage. Maybe you are in incognito. Maybe you are not using your own computer etc. Not particularly likely it will ever sync again.
You are setting different goals: a client (non-web) app running on a different computer would not have access to local storage for another computer where that same app was running locally. FWIW, even on the same computer, you can frequently run the same client using a different profile, user account or similar, and it wouldn't have access to another instance of that same client.
Browser does have local storage and you can assume it keeps the local storage.
The main difference is that browsers tend to be "OSes" for multiple apps.
You wouldn't install and configure an app on a different machine for quick instance. Which you do for a webpage. Hence outlook can't assume that the message can be recovered because it can't assume it will ever see that local storage again.
A webapp has it's place. It is an inferior option but it is convenient for when you lack access to a proper client, doesn't make sense for them to target the same goals.
I am surprised you still insist on the assymetry: there is nothing guaranteeing you'd ever start up that desktop client again.
While it is easier to set up a "transient" web app client, it's also easier to get up a "permanent" web app client, and many people do use the very same computer and browser for accessing a web app just the same.
https://philpapers.org/rec/SIDTAM
> According to an intuitive semantics for 'I,' 'here' and 'now,' 'I am not here now' should always be false when uttered. But occurrences of 'I am not here now' on an answering machine seem to be true (when the speaker is not home).
(If you're interested, you can google for "answering machine paradox" for more takes on it.)