Nearest Fitting Context

I have got the impression, that sentences in human language are usually understood (interpreted by a listener) in the NearestFittingContext. By this I mean, that the listener assumes, that the speaker used only and exactly those words needed to carry the intended meaning.

Example:

Writing about this topic is not easy.

Which topic is meant? "This". It could be any topic. But you will assume, that if I meant any specific one not yet covered by me (on this page or known to be my favorite topic), I would have said so. Thus the topic must be "What is the NearestFittingContext?".
How difficult is it for me to write about it? "Not easy" could be difficult, very difficult, outright hard. But because I said "not easy" you will assume just that, The nearest fit would be on the border, just beyond easy.
What kind of writing is meant? Writing as a writer in general? No. You will assume, that I meant the current writing in the WikiEditBox?. Otherwise I would have said so (at least in this contrived example). You might also assume, that I meant "explaining", because writing (typing) itself is usually not considered hard, if so, I would have elaborated that point.

On the other hand, when I say something, I feel compelled to include only exactly those pieces of information, that are out of the ordinary - special.

-- GunnarZarncke

You discuss a communications context. You should note that there is much more to communications contexts than 'exact wording'. There is also: who is speaking, posture, visible features of mood and emotional state, and more. It is quite possible to know that when Bob says "not easy", he means "NP Complete" or "interesting" or both, depending on the context; when David says "not easy", what he really means is that "it is difficult or impossible to prove you have a correct approach"; and that when Gunnar says "not easy", what he really means is "It'll take more effort to implement it than would a task I qualify as 'easy'". If you wish to look into CommunicationsContext?, you ought to look at the whole thing and all the heuristics humans utilize to understand communications. Starting the foray into this subject with a simplification focusing on the NearestFittingContext heuristic seems, to me, an injustice on the subject.
I fully agree that the context is much larger in general than I explained with the initial sentence and implied with my example. That's because I wasn't fully aware of that when I wrote it initially. I invite you rewrite it to reflect this (your remark will do as well, but that's not as readable -> DocumentMode). -- .gz

[NOTE: This example may provide more heat than light for this discussion. Perhaps some rewording and focused debate?]

Example copied from ItDoesntDepend:

What's two plus two? ItDoesntDepend. It is four. There is no need to make issues out of definite and precise facts.

The answer depends upon context.

But a context is assumed if it is not supplied. Where two people communicating share a common context, that context is assumed in the communication unless one party specifies what their context is.

Thus if two average people are communicating and one says "What's two plus two?" the context of decimal arithmetic is an underlying assumption because it is the normal use of numbers and plus. If two fuzzy logic mathematicians are talking and one says "What's two plus two?" while they've been discussing fuzzy logic the context of fuzzy logic would be assumed. One mathematician would have to say "In decimal arithmetic, what's two plus two?" to change the context.

Actually, it's scalar arithmetic, since that's what most people are familiar with. There's a difference; 'decimal' is a specific representation of a value (2 + 2 = 4), not the value. When discussing scalar arithmetic, two plus two is four in any language, and in any representation. "?Que es dos e dos? Quatro." If 2 + 2 = 10 (base 4), '10' still has the same value - the same message - as 'four'. Of course, it's quite reasonable to assume that this is what you meant all along: the when discussing scalar arithmetic is the important context here.

If two complete strangers meet and one begins talking with "What's two plus two?" the normal context of decimal arithmetic would also be assumed provided the second person speaks the same language. If they don't speak the same language it will quickly be discovered that they have no common context in which to communicate.

Yee, hah! And the SimpleWebs Wiki community has discovered Yet Another fairly abstract, neo-philisophical discussion which translates directly into our overall discussion of software development. The Nearest Fitting Context Rule should be one we apply to all UI implementations, where the user will make choices and interpret UI presentations based on what was the last thing the UI told him or decision it forced him to make. Nothing exists in a vacuum, and if we design a UI that leaves the user hanging because we haven't clearly established the context within which he needs to make a choice then the user is going to revert to the most recent thing he saw or did. Consider how our applications are going to get hosed if a user gets to a selection menu via multiple paths and the context is different for each path. Ouch.

Despite the level of sarcasm oozing off that statement, I'll need to agree with the more literal interpretation. The future of UserInterfaces is the UserAgent? -- a semi-intelligent program that will, indeed, utilize such things as CommunicationsContext? to better translate observations on a user into intent and action... and it will be two-way; humans are very well equipped to understand and remember context, be it visual or otherwise. It is natural for users to get to options dialogues (be they selection menus or otherwise) by different paths and to have the context be different for each path. If you right-click on one object (a context) vs. another object (a different context), you definitely expect the same menu options to have different effects. Your cynicism, though noted, is hardly warranted.

Actually, I was being dead serious. UI design needs to disambiguate all choices offered to the user regardless of context. Consider this popup box:

 [Really delete? (Yes) (No)]

How the heck can the user make an intelligent decision based on that dialog? (Obviously by remembering that he/she just selected the 'delete' action on Oonyoffs.) Now try this popup:

 [Really delete "Oonyoffs"? (Yes) (No) (Cancel)]

Now the user has more information to work with. He even has an escape route in case this is something that popped up before lunch and he is just now getting back to it and can't recall what the heck he was doing in the first place.

All UI designs need to take such potential usage into account. This kind of self-documenting (I really hate that phrase) presentation is applicable to more than just user interfaces, of course, but they are the software component that most commonly suffers from inattention to this level of detail. Eh? -- MartySchrader

'How can the user make an intelligent decision based on a [Really delete it? (Yes) (No)] dialog?' If the NearestFittingContext rule were applied correctly, then this dialog would only be shown if it were obvious e.g. currently selected, mentioned just before, requested verbally by the user... If it is not obvious this violates the rule and a more explicit dialog had to be used (as you yourself proposed). Even your example would be bad if "Oonyoffs" were ambigous and the disambiguation impossible for the user (as far as the UI can tell). -- .gz

Are you really choosing to misunderstand me, or is my meaning that muddy? As I said, the choices offered to the user must be disambiguated right at the decision point. Use as much supporting information as needed to provide that disambiguation. -- MartySchrader

One task of the UI is to avoid inundating the user with unnecessary information and unnecessary requests for input. If the entire context can be provided without violating this principle, then things can be done as you suggest. Often, however, you cannot. As a note, one unnecessary request for input is "Should I really delete this thing you just asked me to delete?". Users will much better handle an undo capability than such annoying second-guessing as this. However, I understand that this is a didactic example.

I wonder why you didn't go just a little more extreme with the example:

 [Really? (Yes) (No)] or just [(Yes) (No)]

Of course, I recommend against second-guessing the user; pop-up, attention-seeking dialogues ought to be reserved for when some exceptional, attention-worthy events must be described and acted upon. In this case, the description would be the context, as it doesn't arise directly from the communications context extant between the user and the UI. An options-dialog can have reduced context only when it arises naturally from a user action or naturally within the current communications context.

As far as going off to lunch and attempting to recall the context thus far: that's a difficulty in any conversation where at least one party has a temporally limited memory. If you're talking to someone, you separate to lunch, and you come back an hour or three later, you can hardly expect to continue the conversation exactly where you left off (i.e. speaking the next words as though it were uninterrupted)... and the same is true when working with a computer. Computer UI designed to utilize communications context that might be temporally interrupted must be able to handle this sort of situation e.g. by allowing one to click-and-expand a log of conversation or deep context tree that cannot be summarized to your eight-character 'Oonyoffs', or by allowing a 'cancel' as you suggest.

I agree. So I ask MartySchrader where he thinks the NearestFittingContext rule is violated. -- .gz

I can't help but think that MartySchrader would consider that an irrelevant question. I'm under the impression he believes that the complete communications context ought to be provided to the user at any point the user must make a decision, such that the nature of the decision is entirely disambiguated even if the surrounding context is lost (e.g. after going to lunch). I.e. his position is essentially: "NearestFittingContext shouldn't be used in UI, therefore it's hardly relevant where I think the so-called 'rule' is violated. Suck it up and provide the complete context." It is an idea with some merit, though it will bump heads with information management (users can only process so much information in any given period; providing the whole communication context is somewhat like repeating back the entire story thus far before EVERY choice in a choose-your-own-adventure).

Actually, I am saying that context needs disambiguation relative to the scope and scale of the action requiring user input. Compare these two examples:

 [Really? (Yes) (No)]
 [Really launch nuclear missiles at Russia? (Yes) (No)]

Now, which of these two prompts would you like to have come up in front of the President when he's in the WH Situation Room monitoring an international emergency?

On the other hand, a simple delete action requiring confirmation may just appear as

 [Delete <filename>? (Yes) (No)]

and everybody would be cool with it.

So, yes -- context is king. Describing it is relative to how critical it is if you don't. -- MartySchrader

Whether you need to 'ask' at all really depends on whether 'Undo' is feasible. Even for launching nuclear missiles, perhaps we should offer a non-obtrusive message: "Missiles are now authorized and pending launch at Russia. Click _here_ to abort prior to completion. Progress:***.....". All the obtrusive stuff for launching missiles should have been in the way before the final prompt.

High-level summaries of context, supported by ProgressiveDisclosure of the full context (which would do well to be fully traceable), should support users in making the decisions they must without inundating them with information.

I have observed that many (most?) jokes depend on intentionally violating the NearestFittingContext assumption.

Word games do so by choosing a non-default interpretation of a word.
Other jokes set up a scenario where the default interpretation of the szenario is then invalidated by some further bit - causing the aha.

See: UniverseOfDiscourse, DefiningContext

CategoryNaturalLanguage, CategoryDesignIssues