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.


Writing about this topic is not easy.

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

[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. 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.
See: UniverseOfDiscourse, DefiningContext

CategoryNaturalLanguage, CategoryDesignIssues

View edit of July 9, 2010 or FindPage with title or text search