There Was an Error That Is Preventing Your Entry From Being Submitted. Please Try Again
This browser is no longer supported.
Upgrade to Microsoft Border to have reward of the latest features, security updates, and technical support.
Error Messages in Windows 7
Annotation
This blueprint guide was created for Windows vii and has not been updated for newer versions of Windows. Much of the guidance still applies in principle, only the presentation and examples do non reverberate our electric current design guidance.
Error messages in Windows vii alert users of issues that have already occurred. In dissimilarity, warning messages alarm users of conditions that might cause problems in the time to come. Error letters can be presented using modal dialog boxes, in-place letters, notifications, or balloons.
A typical modal error message.
Effective error messages inform users that a problem occurred, explicate why it happened, and provide a solution so users can set up the trouble. Users should either perform an action or alter their behavior as the result of an mistake message.
Well-written, helpful error messages are crucial to a quality user experience. Poorly written mistake messages effect in low product satisfaction, and are a leading crusade of avoidable technical support costs. Unnecessary fault messages interruption users' flow.
Note: Guidelines related to dialog boxes, warning messages, confirmations, standard icons, notifications, and layout are presented in split articles.
Is this the correct user interface?
To determine, consider these questions:
- Is the user interface (UI) presenting a trouble that has already occurred? If non, the message isn't an error. If the user being alerted of a condition that might crusade a problem in the future, use a alert message.
- Tin the problem be prevented without causing confusion? If so, prevent the trouble instead. For example, employ controls that are constrained to valid values instead of using unconstrained controls that may require error letters. Also, disable controls when clicking would result in fault, equally long as it's obvious why the control is disabled.
- Can the problem exist corrected automatically? If so, handle the problem and suppress the error message.
- Are users probable to perform an activity or change their behavior equally the consequence of the message? If not, the condition doesn't justify interrupting the user so it's better to suppress the error.
- Is the problem relevant when users are actively using other programs? If so, consider showing the problem using a notification surface area icon.
- Is the problem not related to the electric current user activity, does information technology not require firsthand user action, and can users freely ignore information technology? If so, utilise an action failure notification instead.
- Does the trouble relate to the status of a background job inside a main window? If so, consider showing the problem using a condition bars.
- Are the chief target users IT professionals? If so, consider using an culling feedback mechanism, such equally log file entries or e-mail alerts. Information technology professionals strongly prefer log files for non-critical information.
Blueprint concepts
The characteristics of poor fault messages
Information technology should exist no surprise that in that location are many annoying, unhelpful, and poorly written error letters. And because error letters are oft presented using modal dialogs, they interrupt the user's current activity and demand to exist best-selling before allowing the user to continue.
Part of the problem is that there are so many ways to do it wrong. Consider these examples from the Error Message Hall of Shame:
Unnecessary fault messages
Incorrect:
This example from Windows XP might be the worst error message ever. It indicates that a program couldn't launch because Windows itself is in the process of shutting downwardly. There is zip the user can exercise about this or even wants to do about this (the user chose to shut Windows downward, after all). And by displaying this error message, Windows prevents itself from shutting downward!
The problem: The error message itself is the problem. Aside from dismissing the error message, there is nothing for users to do.
Leading cause: Reporting all fault cases, regardless of users' goals or signal of view.
Recommended culling: Don't written report errors that users don't care near.
"Success" error messages
Incorrect:
This fault message resulted from the user choosing non to restart Windows immediately after programme removal. The program removal was successful from the user's point of view.
The trouble: In that location's no fault from the user's point of view. Aside from dismissing the fault message, there is nothing for users to do.
Leading cause: The task completed successfully from the user's point of view, merely failed from the uninstall programme's point of view.
Recommended alternative: Don't report errors for conditions that users consider acceptable.
Completely useless fault messages
Incorrect:
Users learn that at that place was an error, only have no idea what the error was or what to do about it. And no, information technology's not OK!
The trouble: The mistake message doesn't give a specific problem and there is cypher users can practice about information technology.
Leading cause: Most likely, the program has poor error handling.
Recommended alternative: Design good error handling into the program.
Incomprehensible error messages
Incorrect:
In this instance, the problem statement is clear, simply the supplemental explanation is utterly baffling.
The problem: The problem statement or solution is incomprehensible.
Leading crusade: Explaining the problem from the code's betoken of view instead of the user's.
Recommended alternative: Write error message text that your target users tin can hands understand. Provide solutions that users can actually perform. Design your program'southward mistake message experience don't have programmers etch error messages on the spot.
Error messages that overcommunicate
Incorrect:
In this example, the error message apparently attempts to explain every troubleshooting pace.
The problem: Too much data.
Leading cause: Giving too many details or trying to explain a complicated troubleshooting process within an error message.
Recommended alternative: Avoid unnecessary details. As well, avert troubleshooters. If a troubleshooter is necessary, focus on the most likely solutions and explain the residue past linking to the appropriate topic in Help.
Unnecessarily harsh error letters
Wrong:
The programme'due south inability to find an object hardly sounds catastrophic. And assuming it is catastrophic, why is OK the response?
The problem: The program's tone is unnecessarily harsh or dramatic.
Leading cause: The trouble is due to a problems that appears catastrophic from the program's point of view.
Recommended alternative: Choose language carefully based on the user'south bespeak of view.
Error messages that blame users
Incorrect:
Why make users experience like a criminal?
The problem: The error message is phrased in a way that accuses the user of making an error.
Leading cause: Insensitive phrasing that focuses on the user's behavior instead of the problem.
Recommended culling: Focus on the problem, non the user action that led to the problem, using the passive voice equally necessary.
Silly fault messages
Incorrect:
In this example, the trouble statement is quite ironic and no solutions are provided.
The problem: Error message statements that are empty-headed or non-sequitors.
Leading crusade: Creating error letters without paying attention to their context.
Recommended alternative: Accept your fault messages crafted and reviewed past a writer. Consider the context and the user's state of listen when reviewing the errors.
Developer mistake messages
Incorrect:
In this example, the fault message indicates that in that location is a bug in the program. This error message has significant just to the programmer.
The trouble: Messages intended to assistance the program's developers find bugs are left in the release version of the program. These mistake messages accept no pregnant or value to users.
Leading cause: Programmers using normal UI to make letters to themselves.
Recommended alternative: Developers must conditionally compile all such letters so that they are automatically removed from the release version of a product. Don't waste time trying to make errors similar this comprehensible to users because their merely audition is the programmers.
Poorly presented error messages
Incorrect:
This example has many mutual presentation mistakes.
The problem: Getting all the details wrong in the error message presentation.
Leading cause: Not knowing and applying the error bulletin guidelines. Not using writers and editors to create and review the error messages.
The nature of fault handling is such that many of these mistakes are very easy to make. It'southward agonizing to realize that nigh error messages could be nominees for the Hall of Shame.
The characteristics of good mistake messages
In contrast to the previous bad examples, good error messages have:
- A problem. States that a trouble occurred.
- A cause. Explains why the problem occurred.
- A solution. Provides a solution and so that users can set up the trouble.
Additionally, good error messages are presented in a mode that is:
- Relevant. The message presents a problem that users care well-nigh.
- Actionable. Users should either perform an action or change their behavior every bit the issue of the message.
- User-centered. The bulletin describes the problem in terms of target user deportment or goals, non in terms of what the code is unhappy with.
- Cursory. The bulletin is as short every bit possible, but no shorter.
- Clear. The message uses plainly language then that the target users can easily sympathize trouble and solution.
- Specific. The message describes the problem using specific language, giving specific names, locations, and values of the objects involved.
- Courteous. Users shouldn't be blamed or made to experience stupid.
- Rare. Displayed infrequently. Often displayed mistake messages are a sign of bad blueprint.
By designing your mistake treatment experience to accept these characteristics, y'all tin proceed your program'south error messages out of the Mistake Message Hall of Shame.
Avoiding unnecessary error messages
Often the best error message is no fault bulletin. Many errors can exist avoided through better blueprint, and at that place are often improve alternatives to mistake messages. It's unremarkably better to prevent an error than to written report one.
The most obvious fault messages to avoid are those that aren't actionable. If users are likely to dismiss the message without doing or changing anything, omit the error message.
Some error letters can exist eliminated because they aren't problems from the user's point of view. For instance, suppose the user tried to delete a file that is already in the procedure of existence deleted. While this might exist an unexpected instance from the code's betoken of view, users don't consider this an fault considering their desired outcome is achieved.
Incorrect:
This error message should exist eliminated because the activeness was successful from the user's signal of view.
For some other example, suppose the user explicitly cancels a chore. For the user'due south bespeak of view, the following condition isn't an mistake.
Incorrect:
This error message should also be eliminated because the activeness was successful from the user's betoken of view.
Sometimes error messages can be eliminated by focusing on users' goals instead of the technology. In doing and so, reconsider what an fault really is. Is the problem with the user's goals, or with your program's ability to satisfy them? If the user's action makes sense in the real world, it should make sense in software besides.
For case, suppose within an due east-commerce program a user tries to find a product using search, only the literal search query has no matches and the desired product is out of stock. Technically, this is an error, but instead of giving an error message, the program could:
- Continue to search for products that well-nigh closely friction match the query.
- If the search has obvious mistakes, automatically recommend a corrected query.
- Automatically handle mutual problems such as misspellings, alternative spellings, and mismatching pluralization and verb cases.
- Bespeak when the production will exist in stock.
As long as the user's asking is reasonable, a well designed e-commerce plan should return reasonable results non errors.
Another neat style to avoid error messages is by preventing bug in the beginning place. You can prevent errors by:
- Using constrained controls. Use controls that are constrained to valid values. Controls like lists, sliders, check boxes, radio buttons, and engagement and fourth dimension pickers are constrained to valid values, whereas text boxes are often not and may require error letters. Nevertheless, yous can constrain text boxes to accept merely certain characters and have a maximum number of characters.
- Using constrained interactions. For drag operations, allow users to driblet only on valid targets.
- Using disabled controls and carte du jour items. Disable controls and menu items when users can easily deduce why the command or menu item is disabled.
- Providing skilful default values. Users are less likely to brand input errors if they tin take the default values. Fifty-fifty if users decide to modify the value, the default value lets users know the expected input format.
- Making things but work. Users are less probable to make mistakes if the tasks are unnecessary or performed automatically for them. Or if users make small mistakes simply their intention is clear, the trouble is fixed automatically. For example, y'all can automatically right minor formatting problems.
Providing necessary error messages
Sometimes you actually practice need to provide an error message. Users brand mistakes, networks and devices cease working, objects can't be found or modified, tasks tin can't be completed, and programs take bugs. Ideally, these problems would happen less often for example, we can design our software to prevent many types of user mistakes only it isn't realistic to prevent all of these bug. And when one of these issues does happen, a helpful mistake message gets users back on their anxiety quickly.
A common belief is that fault letters are the worst user experience and should exist avoided at all costs, merely it is more accurate to say that user defoliation is the worst experience and should be avoided at all costs. Sometimes that cost is a helpful error message.
Consider disabled controls. Most of the fourth dimension, it is obvious why a control is disabled, so disabling the control is a great mode to avoid an fault message. However, what if the reason a command is disabled isn't obvious? The user can't continue and at that place is no feedback to determine the problem. Now the user is stuck and either has to deduce the problem or go technical support. In such cases, it's much better to leave the command enabled and give a helpful error message instead.
Incorrect:
Why is the Next push disabled here? Meliorate to leave it enabled and avoid user confusion by giving a helpful error message.
If yous aren't sure whether you should give an mistake message, get-go by composing the fault message that you lot might give. If users are likely either to perform an action or to alter their behavior as a result, provide the mistake bulletin. By dissimilarity, if users are probable to dismiss the message without doing or irresolute anything, omit the error bulletin.
Designing for good error treatment
While crafting good error message text can be challenging, sometimes information technology is impossible without good error handling back up from the programme. Consider this error message:
Incorrect:
Chances are, the problem actually is unknown because the programme's error treatment support is lacking.
While it'due south possible that this is a very poorly written error bulletin, it more likely reflects the lack of good fault handling by the underlying lawmaking there is no specific information known nearly the problem.
In order to create specific, actionable, user-centered error messages, your programme'southward error handling code must provide specific, high-level error information:
- Each problem should take a unique fault code assigned.
- If a problem has several causes, the program should decide the specific cause whenever possible.
- If the problem has parameters, the parameters must be maintained.
- Low-level bug must be handled at a sufficiently loftier level so that the fault message tin can be presented from the user's betoken of view.
Good fault letters aren't just a UI problem, they are a software blueprint trouble. A good error message experience isn't something that can exist tacked on afterwards.
Troubleshooting (and how to avoid it)
Troubleshooting results when a problem with several different causes is reported with a single fault bulletin.
Wrong:
Correct:
Troubleshooting results when several problems are reported with a single error message.
In the following example, an item couldn't be moved because it was already moved or deleted, or access was denied. If the programme can easily decide the crusade, why put the burden on the user to determine the specific cause?
Wrong:
Well, which is it? At present the user has to troubleshoot.
The plan tin can make up one's mind if access was denied, then this problem should exist reported with a specific error message.
Correct:
With a specific crusade, no troubleshooting is required.
Apply messages with multiple causes simply when the specific cause cannot be determined. In this example, it would exist difficult for the program to determine if the item was moved or deleted, so a single mistake message with multiple causes might be used here. Even so, information technology's unlikely that users are going to care if, for case, they couldn't move a deleted file. For these causes, the fault bulletin isn't fifty-fifty necessary.
Handling unknown errors
In some cases, you genuinely won't know the problem, cause, or the solution. If it would exist unwise to suppress the error, it is amend to be upwardly front about the lack of information than to present problems, causes, or solutions that might not exist right.
For example, if your plan has an unhandled exception, the post-obit error message is suitable:
If you can't suppress an unknown error, information technology is improve to be upwards forepart about the lack of data.
On the other hand, do provide specific, actionable information if it is probable to exist helpful most of the time.
This error message is suitable for an unknown error if network connectivity is usually the trouble.
Determine the appropriate message type
Some issues can be presented as an error, warning, or data, depending on the emphasis and phrasing. For example, suppose a Web folio cannot load an unsigned ActiveX control based on the electric current Windows Internet Explorer configuration:
- Fault. "This page cannot load an unsigned ActiveX control." (Phrased equally an existing problem.)
- Warning. "This folio might not behave as expected considering Windows Internet Explorer isn't configured to load unsigned ActiveX controls." or "Allow this page to install an unsigned ActiveX Control? Doing so from untrusted sources may harm your computer." (Both phrased as conditions that may cause time to come bug.)
- Information. "You have configured Windows Internet Explorer to block unsigned ActiveX controls." (Phrased as a statement of fact.)
To determine the advisable message type, focus on the about important aspect of the issue that users demand to know or act upon. Typically, if an consequence blocks the user from proceeding, yous should nowadays it every bit an error; if the user tin can proceed, nowadays it as a warning. Arts and crafts the master instruction or other respective text based on that focus, then cull an icon (standard or otherwise) that matches the text. The main instruction text and icons should always match.
Error bulletin presentation
Near fault letters in Windows programs are presented using modal dialog boxes (every bit are most examples in this commodity), just in that location are other options:
- In-place
- Balloons
- Notifications
- Notification surface area icons
- Condition bars
- Log files (for errors targeted at It professionals)
Putting error messages in modal dialog boxes has the benefit of demanding the user's immediate attention and acknowledgement. All the same, this is also their primary drawback if that attention isn't necessary.
Do you really demand to interrupt users so that they tin can click the Close push button? If not, consider alternatives to using a modal dialog box.
Modal dialogs are a great choice when the user must acknowledge the problem immediately before standing, but often a poor choice otherwise. Generally, you should prefer to use the lightest weight presentation that does the job well.
Avoid overcommunicating
By and large, users don't read, they browse. The more text there is, the harder the text is to browse, and the more likely users won't read the text at all. As a result, it is important to reduce the text down to its essentials, and use progressive disclosure and Help links when necessary to provide additional data.
There are many farthermost examples, but let'due south look at one more typical. The following example has most of the attributes of a skilful mistake message, merely its text isn't concise and requires motivation to read.
Incorrect:
This example is a adept error message, but it overcommunicates.
What is all this text really proverb? Something similar this:
Correct:
This error bulletin has essentially the aforementioned information, but is far more concise.
Past using Help to provide the details, this fault message has an inverted pyramid style of presentation.
For more guidelines and examples on overcommunicating, encounter User Interface Text.
If you do only eight things
- Pattern your programme for mistake handling.
- Don't give unnecessary mistake messages.
- Avert user confusion by giving necessary mistake letters.
- Make certain the fault message gives a trouble, crusade, and solution.
- Make sure the error message is relevant, actionable, cursory, clear, specific, courteous, and rare.
- Blueprint error messages from the user'due south betoken of view, not the programme's betoken of view.
- Avert involving the user in troubleshooting use a different error bulletin for each detectable cause.
- Use the lightest weight presentation method that does the job well.
Usage patterns
Mistake messages have several usage patterns:
| Label | Value |
|---|---|
| System problems The operating system, hardware device, network, or program has failed or is not in the country required to perform a task. | Many system problems can be solved past the user:
 In this case, the program can't find a camera to perform a user task.  In this instance, a feature required to perform a task needs to be turned on. |
| File problems A file or folder required for a task initiated by the user was not institute, is already in employ, or doesn't have the expected format. |  In this example, the file or folder can't exist deleted because information technology wasn't found.  In this example, the plan doesn't back up the given file format. |
| Security bug The user doesn't have permission to access a resource, or sufficient privilege to perform a task initiated past the user. |  In this example, the user doesn't have permission to access a resource.  In this example, the user doesn't take the privilege to perform a job. |
| Task problems There is a specific trouble performing a task initiated by the user (other than a system, file not institute, file format, or security trouble). |  In this example, the Clipboard data can't be pasted into Paint.  In this example, the user can't install a software upgrade. |
| User input bug The user entered a value that is incorrect or inconsistent with other user input. |  In this instance, the user entered an wrong fourth dimension value.  In this example, user input is not in the correct format. |
Guidelines
Presentation
- Use task dialogs whenever appropriate to achieve a consistent look and layout. Job dialogs require Windows Vista or later, then they aren't suitable for before versions of Windows. If y'all must apply a message box, separate the main education from the supplemental instruction with two line breaks.
User input errors
- Whenever possible, prevent or reduce user input errors by:
- Using controls that are constrained to valid values.
- Disabling controls and menu items when clicking would result in mistake, as long as it's obvious why the control or card particular is disabled.
- Providing good default values.
Incorrect:
In this instance, an unconstrained text box is used for constrained input. Use a slider instead.
- Use modeless error handling (in-place errors or balloons) for contextual user input issues.
- Use balloons for not-critical, single-indicate user input problems detected while in a text box or immediately later a text box loses focus.Balloons don't require bachelor screen space or the dynamic layout that is required to brandish in-place letters. Display only a single balloon at a time. Because the problem isn't disquisitional, no error icon is necessary. Balloons become away when clicked, when the problem is resolved, or afterward a timeout.
In this example, a balloon indicates an input problem while still in the control.
- Use in-identify errors for delayed mistake detection, commonly errors found by clicking a commit button. (Don't use in-place errors for settings that are immediately committed.) There tin can be multiple in-place errors at a fourth dimension. Use normal text and a 16x16 pixel fault icon, placing them directly next to the problem whenever possible. In-identify errors don't go abroad unless the user commits and no other errors are establish.
In this case, an in-place fault is used for an fault found by clicking the commit push button.
- Use modal fault treatment (chore dialogs or bulletin boxes) for all other problems, including errors that involve multiple controls or are non-contextual or not-input errors institute by clicking a commit push button.
- When a user input problem is reported, ready input focus to the start control with the wrong information. Scroll the control into view if necessary. If the control is a text box, select the entire contents. It should e'er be obvious what the error message is referring to.
- Don't clear incorrect input. Instead, get out it so that the user can see and right the problem without starting over.
- Exception: Articulate wrong password and PIN text boxes because users tin can't correct masked input finer.
Troubleshooting
- Avoid creating troubleshooting bug. Don't rely on a single error message to written report a problem with several different detectable causes.
- Apply a dissimilar error bulletin (typically a different supplemental instruction) for each detectable cause. For example, if a file cannot be opened for several reasons, provide a separate supplemental instruction for each reason.
- Use a message with multiple causes only when the specific crusade can't be determined. In this case, nowadays the solutions in order of likelihood of fixing the problem. Doing so helps users solve the problem more efficiently.
Icons
-
Modal fault message dialogs don't have title bar icons. Title bar icons are used every bit a visual distinction between chief windows and secondary windows.
-
Use an error icon. Exceptions:
-
If the error is a user input problem displayed using a modal dialog box or balloon, don't apply an icon. Doing and then is counter to the encouraging tone of Windows. However, in-place mistake messages should use a small error icon (16x16 pixel) to conspicuously identify them every bit error letters.
In these examples, user input problems don't need error icons.
In this instance, an in-identify fault message needs a minor mistake icon to clearly identify information technology as an error bulletin.
-
-
If the trouble is for a feature that has an icon (and not a user input trouble), you can use the feature icon with an error overlay. If you lot practise this, likewise utilize the feature proper noun as the error's subject.
In this case, the feature icon has an mistake overlay, and the characteristic is the subject of the fault.
-
Don't use warning icons for errors. This is oftentimes done to make the presentation feel less severe. Errors aren't warnings.
Incorrect:
In this example, a warning icon is incorrectly used to make the error feel less severe.
For more guidelines and examples, see Standard Icons.
Progressive disclosure
- Use a Show/Hide details progressive disclosure push to hide advanced or detailed information in an error message. Doing then simplifies the fault message for typical usage. Don't hide needed data, considering users might non discover information technology.
In this example, the progressive disclosure button helps users drill downwardly to more than detail if they want information technology, or simplify the UI if they don't.
- Don't apply Prove/Hibernate details unless there really is more detail. Don't only restate the existing information in a more verbose format.
- Don't use Show/Hide details to show Help information. Use Help links instead.
For labeling guidelines, see Progressive Disclosure Controls.
Don't prove this bulletin over again
- If an error message needs this pick, reconsider the fault and its frequency. If it has all the characteristics of a expert mistake (relevant, actionable, and infrequent), it shouldn't make sense for users to suppress it.
For more guidelines, see Dialog Boxes.
Default values
- Select the safest, least destructive, or most secure response to be the default. If safety isn't a factor, select the most probable or convenient control.
Help
- Blueprint fault letters to avoid the need for Help. Ordinarily users shouldn't have to read external text to understand and solve the problem, unless the solution requires several steps.
- Make certain the Help content is relevant and helpful. It shouldn't exist a verbose restatement of the error message rather, it should comprise useful data that is beyond the telescopic of the error message, such as means to avoid the problem in the time to come. Don't provide a Assistance link simply because you can.
- Utilize specific, concise, relevant Aid links to access Help content. Don't use control buttons or progressive disclosure for this purpose.
- For error messages that y'all tin can't make specific and actionable, consider providing links to online Help content. Past doing so, you can provide users with additional information that you can update after the program is released.
For more guidelines, run across Help.
Error codes
- For fault letters that you can't make specific and actionable or they benefit from Assist, consider also providing fault codes. Users oft use these mistake codes to search the Internet for boosted information.
- Always provide a text description of the problem and solution. Don't depend just on the error code for this purpose.
Incorrect:
In this case, an error code is used equally a substitute for a solution text.
- Assign a unique error lawmaking for each dissimilar cause. Doing so avoids troubleshooting.
- Choose error codes that are easily searchable on the Internet. If you employ 32-scrap codes, use a hexadecimal representation with a leading "0x" and capital characters.
Correct:
1234
0xC0001234
Incorrect:
-i
-67113524
- Use Prove/Hide details to brandish mistake codes. Phrase equally Error code:
<error code>.
In this case, an mistake code is used to supplement an fault message that can benefit from farther information.
Sound
- Don't accompany fault messages with a audio effect or beep. Doing so is jarring and unnecessary.
- Exception: Play the Critical Stop sound effect if the problem is critical to the functioning of the computer, and the user must have immediate action to prevent serious consequences.
Text
General
- Remove redundant text. Look for it in titles, master instructions, supplemental instructions, command links, and commit buttons. Generally, leave full text in instructions and interactive controls, and remove any redundancy from the other places.
- Apply user-centered explanations. Describe the problem in terms of user deportment or goals, non in terms of what the software is unhappy with. Use language that the target users sympathize and use. Avoid technical jargon.
Incorrect:
Correct:
In these examples, the correct version speaks the user's language whereas the incorrect version is overly technical.
- Don't utilize the post-obit words:
- Error, failure (use problem instead)
- Failed to (utilize unable to instead)
- Illegal, invalid, bad (use incorrect instead)
- Abort, impale, terminate (use terminate instead)
- Catastrophic, fatal (use serious instead)
These terms are unnecessary and contrary to the encouraging tone of Windows. When used correctly, the error icon sufficiently communicates that there is a problem.
Incorrect:
Right:
In the wrong example, the terms "catastrophic" and "failure" are unnecessary.
- Don't use phrasing that blames the user or implies user error. Avoid using you and your in the phrasing. While the active voice is generally preferred, utilize the passive voice when the user is the subject and might feel blamed for the error if the active voice were used.
Incorrect:
Correct:
The incorrect example blames the user by using the active voice.
- Be specific. Avoid vague wording, such equally syntax mistake and illegal functioning. Provide specific names, locations, and values of the objects involved.
Wrong:
File not found.
Disk is full.
Value out of range.
Character is invalid.
Device not bachelor.
These problems would be much easier to solve with specific names, locations, and values.
- Don't give possibly unlikely problems, causes, or solutions in an attempt to exist specific. Don't provide a trouble, cause, or solution unless it is likely to be right. For case, it is better to say An unknown mistake occurred than something that is probable to be inaccurate.
- Avoid the word "please," except in situations in which the user is asked to do something inconvenient (such as waiting) or the software is to arraign for the situation.
Correct:
Please wait while Windows copies the files to your computer.
- Use the word "deplorable" only in error messages that result in serious problems for the user (for example, data loss or inability to use the computer). Don't apologize if the issue occurred during the normal functioning of the program (for example, if the user needs to wait for a network connexion to exist constitute).
Right:
We're sorry, just Fabrikam Backup detected an unrecoverable problem and was shut downward to protect files on your computer.
- Refer to products using their brusque names. Don't use full product names or trademark symbols. Don't include the company name unless users associate the visitor name with the production. Don't include program version numbers.
Wrong:
Correct:
In the incorrect example, total production names and trademark symbols are used.
- Utilize double quotation marks around object names. Doing so makes the text easier to parse and avoids potentially embarrassing statements.
- Exception: Fully qualified file paths, URLs, and domain names don't need to be in double quotation marks.
Right:
In this case, the error message would be confusing if the object proper name weren't in quotation marks.
- Avoid starting sentences with object names. Doing so is frequently difficult to parse.
- Don't use exclamation marks or words with all uppercase letters. Exclamation marks and capital letters make information technology feel similar you are shouting at the user.
For more guidelines and examples, run into Style and Tone.
Titles
- Use the championship to identify the command or feature from which the mistake originated. Exceptions:
- If an error is displayed past many different commands, consider using the plan name instead.
- If that championship would be redundant or disruptive with the chief instruction, use the plan name instead.
- Don't use the title to explain or summarize the problem that's the purpose of the chief instruction.
Wrong:
In this example, the title is beingness incorrectly used to explain the problem.
- Use title-style capitalization, without ending punctuation.
Main instructions
- Use the main instruction to describe the trouble in clear, plain, specific language.
- Be concise use only a single, complete judgement. Peel the master instruction down to the essential data. You tin can leave the field of study implicit if information technology is your program or the user. Include the reason for the problem if you tin do so concisely. If you must explain anything more, utilise a supplemental instruction.
Wrong:
In this example, the entire mistake message is put in the main instruction, making it hard to read.
- Exist specific if there are objects involved, give their names.
- Avoid putting full file paths and URLs in the principal educational activity. Rather, use a short proper noun (such every bit the file name) and put the full name (such as the file path) in the supplemental instruction. Even so, yous can put a single full file path or URL in the principal didactics if the error bulletin doesn't otherwise need a supplemental pedagogy.
In this example, just the file name is in the main instruction. The full path is in the supplemental teaching.
- Don't requite the full file path and URL at all if it's obvious from the context.
In this example, the user is renaming a file from Windows Explorer. In this case, the full file path isn't needed considering it's obvious from the context.
- Use present tense whenever possible.
- Use sentence-fashion capitalization.
- Don't include final periods if the teaching is a statement. If the instruction is a question, include a final question mark.
Principal instruction templates
While there are no strict rules for phrasing, try using the following main instruction templates whenever possible:
- [optional discipline name] can't [perform action]
- [optional field of study name] tin can't [perform action] considering [reason]
- [optional subject name] can't [perform action] to "[object name]"
- [optional subject proper noun] can't [perform activity] to "[object proper noun]" considering [reason]
- There is non enough [resource] to [perform action]
- [Subject area name] doesn't have a [object name] required for [purpose]
- [Device or setting] is turned off so that [undesired results]
- [Device or setting] isn't [available | establish | turned on | enabled]
- "[object proper name]" is currently unavailable
- The user proper noun or password is incorrect
- You don't have permission to admission "[object name]"
- Yous don't have privilege to [perform action]
- [plan proper noun] has experienced a serious problem and must close immediately
Of course, make changes equally needed for the main pedagogy to be grammatically correct and comply with the main instruction guidelines.
Supplemental instructions
- Use the supplemental instruction to:
- Give boosted details about the problem.
- Explain the cause of the problem.
- List steps the user can take to fix the trouble.
- Provide measures to prevent the problem from reoccurring.
- Whenever possible, advise a practical, helpful solution so users can fix the trouble. Yet, make sure the proposed solution is likely to solve the trouble. Don't waste users' time by suggesting possible, merely improbable, solutions.
Incorrect:
In this example, while the problem and its recommended solution are possible, they are very unlikely.
- If the problem is an incorrect value that the user entered, employ the supplemental pedagogy to explicate the correct values. Users shouldn't have to determine this information from another source.
- Don't provide a solution if information technology tin can be trivially deduced from the problem statement.
In this example, no supplemental instruction is necessary; the solution tin be trivially deduced from the problem argument.
- If the solution has multiple steps, nowadays the steps in the gild in which they should be completed. However, avoid multi-pace solutions because users take difficulty remembering more than two or three simple steps. If more steps are required, refer to the appropriate Assist topic.
- Keep supplemental instructions concise. Provide just what users need to know. Omit unnecessary details. Aim for a maximum of iii sentences of moderate length.
- To avert mistakes while users perform instructions, put the results before the action.
Correct:
To restart Windows, click OK.
Incorrect:
Click OK to restart Windows.
In the incorrect example, users are more likely to click OK by accident.
- Don't recommend contacting an administrator unless doing so is amongst the most likely solutions to the problem. Reserve such solutions for problems that really can simply be solved by an ambassador.
Incorrect:
In this example, almost likely the problem is with the user's network connection, and so it's not worth contacting an administrator.
- Don't recommend contacting technical support. The option to contact technical support to solve a problem is e'er available, and doesn't need to exist promoted through mistake messages. Instead, focus on writing helpful error messages and so that users tin solve problems without contacting technical back up.
Incorrect:
In this example, the error message incorrectly recommends contacting technical support.
- Use complete sentences, sentence-fashion capitalization, and catastrophe punctuation.
Commit buttons
- If the error message provides control buttons or control links that solve the problem, follow their corresponding guidelines in Dialog Boxes.
- If the program must cease as a effect of the error, provide an Get out program button. To avoid confusion, don't use Shut for this purpose.
- Otherwise, provide a Shut push button. Don't use OK for error letters, because this wording implies that problems are OK.
- Exception: Use OK if your mistake reporting mechanism has fixed labels (as with the MessageBox API.)
Documentation
When referring to errors:
- Refer to errors by their master didactics. If the primary instruction is long or detailed, summarize information technology.
- If necessary, you may refer to an error bulletin dialog box as a message. Refer to as an error message merely in programming and other technical documentation.
- When possible, format the text using bold. Otherwise, put the text in quotation marks only if required to prevent confusion.
Case: If yous receive a There is no CD disc in the drive message, insert a new CD disc in the drive and try again.
Source: https://docs.microsoft.com/en-us/windows/win32/uxguide/mess-error
Publicar un comentario for "There Was an Error That Is Preventing Your Entry From Being Submitted. Please Try Again"