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.
I think this is an example of the "answering machine paradox," which philosophers have been writing about since the 1970's.
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.)
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.
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
I rest my case.
Your case was "that made up 'science' is real, and you can't say no because you haven't studied it for years".
I don't need to study astrology for years, to know it's nonsense in about 10 minutes.
Yet I've hear a lot more philosophical blather than that, and so yes, I have enough data to make a determination.
There's an inner logic to tarot cards, books and books on it, but that doesn't make it useful or valuable.
Shocking comment. Do you think the scientific method is inbuilt in our DNA or something? Where do you think it all comes from?
You think it comes from philosophy? This is like claiming our democracy comes from God, because he edictorially spoke through ancient kings!
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:
You very clearly illustrate andybak’s point by showing that you just don’t even know what philosophy is.
So your argument, is that one must spend years studying nonsense, to have an opinion on its worth?
I've already clarified why this is not so. Thus, your main, true disagreement is that you do not agree with my assessment.
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.
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.
One the other hand, the other response to OP's comment is a perfect display of what he means. A lot of tech bro hubris/idiocy.
"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.
Alternatively: placing finger on the peak of Olympus Mons on Martian map
"I am not here now". I'm not seeing the problem.
There are a lot of philosophy 'problems' like this, which leads me to think philosophers lead blessed, problem-free lives.
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.
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.)
Math problems are quite similar in this way!
... not the ones involving the rent check.
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.
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?
Hehe, you’re replying to a comment that exposed issues with the stated assumptions behind the so-called paradox.
They normally expose some problem with our language, and nothing deeper than that. This is a perfect example.
leads me to think philosophers lead blessed, problem-free lives.
I agree, perhaps with the qualification of 'eventually', having been both of these people:
1) someone born dirt poor who had to spend every waking moment to feed myself
2) someone who can pontificate in comment sections
Those who can't do, teach. Those who can't teach wander philosophically.
Playing with ourselves. Man plans, god laughs. Everyone has a plan until they get hit in the mouth. I could go on.
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.
When you say "this", I assume you are referring to the message you were writing at the time.
I think that describes a considerable chunk of the Philosophy field.
But that's of course what an engineer would say.
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.
By the way, that is a great movie. Or do I say "was"?
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.
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.
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 don’t think the model is that far off. In real life I can read a letter and retain the contents in my mind, then burn the letter.
But this is claiming that the letter does not exist, while allowing you to read the contents of the letter.
If it can show you the content, the container must exist!
In a post office, open a letter, burn the envelope. The content now exists, but the message does not.
but that implies the message is the envelope, which is not typically what a message means.
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.
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.
Does Outlook can even have opinions?
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.
if the message never achieved a physical form such as printing, does the message exist?
if the message stopped existing, but nobody was there, did it make the 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)?
isn't paper substantial while magnetic patterns are insubstantial?
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.
What would be transubstantial?
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.
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.
The question remains: how can something that does not exist contain anything?
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.
Well somebody had better discard it now, lest it start existing at some point in the future.
I speaks to Microsoft's creativity that they are able to redefine logic that far.
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.
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.
Ceci n’est pas un message?
You can stuff that in your pipe and smoke it!
Not if it doesn't exist.
Or if it's not a pipe.
"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"
this cracked me up !
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).
the message is not the same as the text.
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’.
“Oh, that's the name of the song, is it?” Alice said, trying to feel interested.
I've had similar philosophical thoughts about a transaction rollback.
Consider this definition from go's database/sql package.
func (tx *Tx) Rollback() error
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.
Falsehoods programmers believe:
- Sleep(1) sleeps for exactly 1 second.
- Sleep(1) sleeps for approximately 1 second.
- Sleep(1) sleeps for at least 1 second.
- Sleep(1) sleeps for an unknown, but short amount of time. Certainly not weeks, months or years.
Sleep(1) sleeps for approximately 1 second.
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).
More Falsehoods programmers believe about time: <https://gist.github.com/timvisee/fcda9bbdff88d45cc9061606b4b...>
Haha, this is one of the best comments I've read on HN
"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!
Obviously, transaction may fail to be rolled back and leave dangling locks. Not sure about the specifics.
That's a bug in your database, not something you specify on your API.
What if it's a connection problem? DBs are normally remote. It's also OK to specify potential bug surface on your API.
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.
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.
I unexpectedly shuddered at the term “dangling locks”
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.
How did you discover the dangling transaction?
By accident. I had found a book from tom kyte in a garage sale, and was looking around in all kinds of views it described.
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.
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.
An example of how a rollback could fail is if the database is accessed over a network and the connection times out due to a networking problem.
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.
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.
This is the most Microsoft error message I have ever seen
Only for a while until someone changes it to "Something went wrong"
Don’t forget “Oops!” — the element of surprise.
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.
I find it as infuriating as you.
With a large :( to redundantly communicate that something bad happened, in case the user didn't even read the simplified message.
Wouldn't a more microsoft message be about competing products failing to exist?
I've seen teams messages on firefox and safari about features not existing "download the teams native app!"
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
Fatal Error: Operation completed successfully.
task failed successfully!
This message will delete itself after this. Please save its contents if you with to retain it.
SharePoint is supposedly one of the keystones of Microsoft.
The answer to "how can I find all SharePoint Sites where I am a member?" is:
Search SharePoint for contentclass:STS_Site
How is this, and op, cluster f possible? How do these decisions get into prod?
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.
If it were a pointer, Microsoft's advice of copying the message would cause a segmentation fault.
Maybe a better comparison would be a weak reference to an object that's in line to being garbage collected.
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.
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.
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.
Of course you can read non-existent messages, for example when an AI hallucinates one
This message clearly exists. It's could be not factually correct, but a lie still exists.
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.
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
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.
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.
The problems you cite with Web apps are not unique to the Web, but to client-server apps in general.
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.
Web app have storage. It is only because the app you use doesn’t use it properly. Even gmail has offline mode.
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.
I want to ask a simpler question - why don't I have a button to make the message exist again if I have the content?
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.
Imagine the meetings and comitees to decide how such a button should be named. They would brobably involve "AI" somehow
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's very easy.
"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.
This reminds of a choice I once saw between the following: “Save this Credit Card” Or “Never save this Credit Card”
With hashing and things, the latter is certainly possible, but I got a good chuckle out of it.
Along those lines, "Don't use cookies on this site".
Uses localStorage of course.
This comment does not exist.
This is not a comment.
We used to hear that LLMs hallucinate but, apparently, we are witnessing the hallucination of apps now!
This reminds me of another quiet funny error message, again, from Microsoft about a Windows Phone error message telling users to "insert CD and Restart Your Computer" ( https://thenextweb.com/news/this-is-the-funniest-windows-err...)
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.
The commentary is golden.
Trying to guess what is going on. I guess they refer to the original message (on the server) and its local copy. Both referred to as "the message".
Which only goes to show that the bad habit of using imprecise terms is liable to produce total confusion.
I find the message self explanatory.
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.
That's not the ntresteing is part.
It has ceased to be
:-) The Dead Parrot Sketch, https://en.wikipedia.org/wiki/Dead_Parrot_sketch
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.
Didn't Jobs say something along the lines of that the problem with Microsoft is that they don't care about their products?
Things like this shows how literally that is true. Make a product, sell a product, what could possibly be the problem with that?
I was sure this was going to be a gen-ai site that is going to generate messages on the fly.
Even after I've read and enjoyed it, I skim the title in the list and still think that's what it must be.
"You don't exist. Go away!" said the server.
Reminds me of the time I wrote on the break room whiteboard at work: "Please to not read this sentence."
Ceci n'est pas un message.
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.
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.
The koan of the message that never existed.
Excellent reflection on an absurd premise, thanks for sharing.
“…Outlook…”
Yeah it is gonna be some palmface story.
My favorite Windows error message:
"Unknown device (not found)"
> 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.
To me it sounds like that the service hogging interrupt 47 is saying that it can't be used for print spooling purposes.
The fix is to add "on the server" to the sentence.
"This message cannot be saved because it no longer exists on the server.", and then it's all solved.
Nor will it ever exist.
... As always, should you or any member of your IM Force be caught or killed, the Secretary will disavow all knowledge of your actions.
I once screen-shotted an intranet application at my work asking the unintentional koan, "One does not exist", next to a button that said, "Create".
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.
This is art
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.
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.”
From the headline, I expected this to be a site that randomly presents you with an AI-generated message, in the style of "This person does not exist".
Me:
Browser:
Server: WTAF are you trying to do, here, man?
Message: Hi everybody!
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.
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.
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.
There is no Antimemetics Division
Microsoft BSOD message Team were moved to Microsoft 365
Open in Thunderbird, it will be there, probably.
I had a similar, though not the same, on new and old Outlook and indeed it appeared on Thunderbird. After an hour or two also appeared on Outlooks.
Schrödinger's email
All messages in Outlook exist only in the liminal dreamspace of Clippy.
Reminds me a lot of "The operation failed with an error: success"
It is messages like this that revealed to me a culture of learned helplessness at Microsoft, and I made a decision to switch to Linux.
Wait until the author learns about pointers.
Any semantic pedantics that involve discussing ontology is always a fun time. This was a fun read.
Dangling pointer. Case closed. Period. Period period. :)
I have some ontological questions.
My sides.
The message is the glue that binds reality and unreality. It exists, existed, never existed, all at the same time.
It is the paradox of creation, of existence, of dissolution and of consciousness.
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.
(Sorry for the gallows humor).
Presumably this is shorthand for ‘The message is no longer stored in the system’
Excuse me but Kant would like a word with this dev.
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):
https://mastodon.gamedev.place/@omarshehata/1123783593602927...
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.
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
Sure, if they want to hire someone. Ain't nobody got time for that.
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.
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.
When you can't open Outlook because you're getting an error, ya might need to fuckin sign in. This is sadly a common occurrence.
though do they want to?
If they can learn, they would've. And then cease being a non-technical user.
I usually learn things without the explicit desire to learn, and then feel happy that I did learn. Perhaps I should learn more.
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.
i tried to write about this here: https://omarshehata.substack.com/p/my-favorite-1980s-canadia...
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".
"locally", "the cloud"
Even that can still be too far. I lean towards “your computer” and “their computer”
Is it local if I stay in the same ZIP code?
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.
every warning or labelling of an issue is because it happened to somebody, and it needed to be prevented.
It's true in the physical world - signs like 'beware of falling pottery' for example. The electronic world is a facsimile of the real world!
Not an issue, replace server with the cloud and remove cache, temporary is fine
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.
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?
Do we really need to? I'd lay odds that the effect remains the same: users dismiss the error/warning without reading it.
Yeah but that would be taking nearly all of the Microsoft out of it ...
How about a dialog with the buttons "Try again", "Save to file...", "Copy to clipboard" and "Discard contents"?
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.
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.
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.
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.
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.
"Copy it to where?"
Or, "Can't i just restore it out of the trash?"
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.
How about your phrasing?
‘your data has been deleted on the server, but that your client still has a cached copy’
"Hello IT? Yes, all my data has been deleted please help! Something about a cash-ay and the server is down!"
“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.”
"What do you mean 'it's been deleted?' It's right here! Stupid computers..."
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.
Maybe pose it as a question to the user, rather than an error message: “This message has been deleted from the server. Do you want to:
- discard it permanently - store this version on the server - save as a file to your computer”
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.