Template:Not a bug

1. Template:Not a bug

1. Template:Not a bug

is a meta-template used on WikiProject Bugs, and related pages, to mark issues that are *not* bugs in the software, but rather intended behaviors, design choices, or requests for new features. This article details the purpose of the template, its usage, parameters, categorization, and best practices for its application. It is aimed at new contributors to the MediaWiki project and those unfamiliar with the bug reporting process. Understanding and correctly using this template is crucial for maintaining a clean and accurate bug tracking system, facilitating efficient developer workflow, and improving the overall quality of the MediaWiki software.

Purpose and Context

The core purpose of the `` template is to clearly and unambiguously communicate that a reported issue is *not* a defect in the code. Mistaking a design decision for a bug wastes developer time and clutters the bug tracking system. This template serves as a signal to both developers and reporters that the issue has been reviewed and determined to be functioning as intended. It's vital to remember that “not a bug” doesn’t mean the reporter’s concern is invalid; it simply means the software is behaving correctly according to its design. Often, these reports are actually Feature requests and should be handled accordingly.

The template also facilitates categorization and reporting on the types of non-bug issues being reported. This data can be valuable for product management and future development planning. Analyzing these reports can reveal common user misunderstandings or areas where the user interface could be improved to better reflect the intended functionality. It's a crucial part of the feedback loop.

Usage

The `` template is placed on the bug report page itself, typically at the top of the page, after any initial comments or classifications. It immediately signals the resolution to anyone viewing the report. The template is designed to be simple to use, with several optional parameters to provide more context.

Here’s the basic syntax:

```wiki ```

This will display a standard “Not a bug” message. However, to provide more specific information, you can use the following parameters:

• `reason`: This is the most important parameter. It explains *why* the issue is not considered a bug. Common reasons include: "intended behavior", "design choice", "works as designed", "not a bug - documentation update needed", "duplicate", "invalid", and "won't fix". The `reason` parameter should be filled in whenever possible.
• `comment`: Provides additional details about the decision. This is useful for explaining complex design choices or providing context for the reporter.
• `category`: Allows for assigning a specific category to the "not a bug" report. This is helpful for tracking trends and identifying areas where user confusion is common. Examples include "UI/UX", "Configuration", "Performance", "Documentation".
• `reporter`: Used to record the reporter who initially flagged the issue. While not always necessary, it can be helpful for follow-up communication.
• `resolution`: Specifies how the issue was resolved, for example, "Inform reporter", "Document feature", "Close as not a bug".

Example with parameters:

```wiki ```

This would display a message indicating that the issue is an intended behavior, provide a comment explaining the reasoning, categorize it as a UI/UX issue, record the reporter, and indicate the resolution.

Parameters in Detail

Let's delve deeper into each parameter and its appropriate usage.

• **`reason`**: This parameter is *critical*. A vague "Not a bug" without a reason is less helpful than a clear explanation. Consider the following examples:

   *   **Poor:** ``
   *   **Good:** ``

   The `reason` should be concise but informative. Use established terminology where possible.

• **`comment`**: This parameter allows for a more detailed explanation. It is particularly useful when the `reason` is somewhat technical or requires further clarification. The comment should be written in a clear and understandable manner, avoiding jargon where possible. Consider the reporter's level of technical expertise when writing the comment.

• **`category`**: This parameter enables categorization of "not a bug" reports. Effective categorization helps identify patterns and areas for improvement. Common categories include:

   *   **UI/UX:** Issues related to the user interface or user experience.
   *   **Configuration:**  Issues stemming from incorrect or unclear configuration options.
   *   **Documentation:**  Issues related to missing or unclear documentation.  Often, "not a bug" reports are simply requests for better documentation.
   *   **Performance:**  Issues related to performance, where the software is functioning as designed but could be optimized. Often requires a Performance analysis.
   *   **Design Choice:**  Issues reflecting a deliberate design decision.
   *   **Feature Request:** Issues that are valid requests for new functionality. These should be linked to a Feature request on Phabricator.
   *   **External Dependency:** Issues caused by limitations or behaviors of external libraries or services.
   *   **Security:** Issues related to security considerations.

• **`reporter`**: While optional, including the reporter's username can be helpful for follow-up communication. It also provides a record of who initially reported the issue. Use the `User:username` syntax to link to the user's page.

• **`resolution`**: This parameter documents how the issue was addressed. Common resolutions include:

   *   **Inform reporter:** The reporter was notified of the decision.
   *   **Document feature:** Documentation was updated to clarify the behavior.
   *   **Close as not a bug:** The issue was closed as a non-bug.
   *   **Redirect to feature request:** The issue was converted into a feature request.
   *   **Duplicate:** The issue was a duplicate of an existing report.

Categorization and Reporting

The `category` parameter is crucial for effective categorization. Consistent use of categories allows for generating reports on the types of non-bug issues being reported. This data can be used to:

• Identify areas where the user interface is confusing.
• Prioritize documentation updates.
• Inform future development planning.
• Improve the overall quality of the software.

Regular reports can be generated to track trends in "not a bug" reports. These reports can reveal common user misunderstandings or areas where the software could be improved to better meet user needs. Consider utilizing tools like MediaWiki API to automate the generation of these reports.

Best Practices

• **Always provide a reason:** Never use the template without specifying a `reason`.
• **Be clear and concise:** Write the `comment` in a clear and understandable manner, avoiding jargon.
• **Consider the reporter:** Write the `comment` with the reporter's level of technical expertise in mind.
• **Use consistent categories:** Maintain a consistent categorization scheme to ensure accurate reporting.
• **Link to relevant documentation:** If the issue is related to documentation, link to the relevant documentation page.
• **Consider a feature request:** If the issue is a valid request for new functionality, create a Feature request on Phabricator and link to it.
• **Inform the reporter:** Whenever possible, inform the reporter of the decision and explain the reasoning. This helps build trust and encourages future contributions.
• **Review before closing:** Double-check the report and the template parameters before closing the issue.
• **Utilize Phabricator integration:** Ensure proper integration with Phabricator for seamless issue tracking.
• **Understand the difference between a bug and a limitation:** A bug is an unintended behavior, while a limitation is a constraint of the system. This distinction is important when using the template.

Related Templates and Pages

• Template:Bug – The template used for reporting actual bugs.
• Template:Duplicate bug - Used for marking duplicate bug reports.
• Template:Feature request - Used for requesting new features.
• Template:Invalid bug - Used for marking invalid bug reports.
• Template:Works as intended – An alternative template with similar functionality.
• MediaWiki:Bug tracking – Information about the bug tracking process.
• Phabricator – The bug tracking system used by the MediaWiki project.
• Help:Reporting bugs – Guidelines for reporting bugs.
• Manual:Configuration – Documentation on configuring MediaWiki.
• Manual:FAQ – Frequently asked questions about MediaWiki.

Advanced Considerations

For experienced users, consider these advanced points:

• **Custom Categories:** You may need to create custom categories to better reflect the specific needs of your project.
• **Scripting:** Automate the application of the template using scripts or bots.
• **API Integration:** Integrate the template with other tools using the MediaWiki API.
• **Trend Analysis:** Perform detailed trend analysis on "not a bug" reports to identify areas for improvement. This could involve Statistical analysis of the data.
• **User Feedback:** Actively solicit user feedback to identify areas where the software is confusing or unintuitive.
• **Usability testing**: Conduct usability testing to identify areas where the user interface can be improved.
• **A/B testing**: Use A/B testing to compare different design options and determine which one performs better.
• **Conversion rate optimization**: Apply conversion rate optimization techniques to improve the user experience and increase user engagement.
• **SEO analysis**: Analyze search engine optimization (SEO) data to identify areas where the software can be improved to attract more users.
• **Competitive analysis**: Conduct competitive analysis to identify best practices and areas where the software can be differentiated.
• **Data mining**: Use data mining techniques to identify patterns and trends in user behavior.
• **Machine learning**: Apply machine learning algorithms to automate tasks and improve the user experience.
• **Big data analytics**: Leverage big data analytics to gain insights into user behavior and identify areas for improvement.
• **Root cause analysis**: Perform root cause analysis to identify the underlying causes of user confusion and frustration.
• **Heuristic evaluation**: Conduct heuristic evaluation to identify usability problems in the user interface.
• **Cognitive walkthrough**: Perform a cognitive walkthrough to simulate how a user would interact with the software.
• **Accessibility testing**: Ensure that the software is accessible to users with disabilities.
• **Localization testing**: Ensure that the software is properly localized for different languages and cultures.
• **Security auditing**: Conduct regular security audits to identify and address potential security vulnerabilities.
• **Penetration testing**: Perform penetration testing to simulate real-world attacks and identify security weaknesses.
• **Risk assessment**: Conduct risk assessments to identify and prioritize potential risks.
• **Compliance auditing**: Ensure that the software complies with relevant regulations and standards.
• **Performance monitoring**: Monitor the performance of the software to identify and address performance bottlenecks.
• **Capacity planning**: Plan for future capacity needs to ensure that the software can handle increased traffic and data volume.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners is a meta-template used on WikiProject Bugs, and related pages, to mark issues that are *not* bugs in the software, but rather intended behaviors, design choices, or requests for new features. This article details the purpose of the template, its usage, parameters, categorization, and best practices for its application. It is aimed at new contributors to the MediaWiki project and those unfamiliar with the bug reporting process. Understanding and correctly using this template is crucial for maintaining a clean and accurate bug tracking system, facilitating efficient developer workflow, and improving the overall quality of the MediaWiki software.

Purpose and Context

The core purpose of the `

1. Template:Not a bug

is a meta-template used on WikiProject Bugs, and related pages, to mark issues that are *not* bugs in the software, but rather intended behaviors, design choices, or requests for new features. This article details the purpose of the template, its usage, parameters, categorization, and best practices for its application. It is aimed at new contributors to the MediaWiki project and those unfamiliar with the bug reporting process. Understanding and correctly using this template is crucial for maintaining a clean and accurate bug tracking system, facilitating efficient developer workflow, and improving the overall quality of the MediaWiki software.

Purpose and Context

The core purpose of the `` template is to clearly and unambiguously communicate that a reported issue is *not* a defect in the code. Mistaking a design decision for a bug wastes developer time and clutters the bug tracking system. This template serves as a signal to both developers and reporters that the issue has been reviewed and determined to be functioning as intended. It's vital to remember that “not a bug” doesn’t mean the reporter’s concern is invalid; it simply means the software is behaving correctly according to its design. Often, these reports are actually Feature requests and should be handled accordingly.

The template also facilitates categorization and reporting on the types of non-bug issues being reported. This data can be valuable for product management and future development planning. Analyzing these reports can reveal common user misunderstandings or areas where the user interface could be improved to better reflect the intended functionality. It's a crucial part of the feedback loop.

Usage

The `` template is placed on the bug report page itself, typically at the top of the page, after any initial comments or classifications. It immediately signals the resolution to anyone viewing the report. The template is designed to be simple to use, with several optional parameters to provide more context.

Here’s the basic syntax:

```wiki ```

This will display a standard “Not a bug” message. However, to provide more specific information, you can use the following parameters:

• `reason`: This is the most important parameter. It explains *why* the issue is not considered a bug. Common reasons include: "intended behavior", "design choice", "works as designed", "not a bug - documentation update needed", "duplicate", "invalid", and "won't fix". The `reason` parameter should be filled in whenever possible.
• `comment`: Provides additional details about the decision. This is useful for explaining complex design choices or providing context for the reporter.
• `category`: Allows for assigning a specific category to the "not a bug" report. This is helpful for tracking trends and identifying areas where user confusion is common. Examples include "UI/UX", "Configuration", "Performance", "Documentation".
• `reporter`: Used to record the reporter who initially flagged the issue. While not always necessary, it can be helpful for follow-up communication.
• `resolution`: Specifies how the issue was resolved, for example, "Inform reporter", "Document feature", "Close as not a bug".

Example with parameters:

```wiki ```

This would display a message indicating that the issue is an intended behavior, provide a comment explaining the reasoning, categorize it as a UI/UX issue, record the reporter, and indicate the resolution.

Parameters in Detail

Let's delve deeper into each parameter and its appropriate usage.

• **`reason`**: This parameter is *critical*. A vague "Not a bug" without a reason is less helpful than a clear explanation. Consider the following examples:

   *   **Poor:** ``
   *   **Good:** ``

   The `reason` should be concise but informative. Use established terminology where possible.

• **`comment`**: This parameter allows for a more detailed explanation. It is particularly useful when the `reason` is somewhat technical or requires further clarification. The comment should be written in a clear and understandable manner, avoiding jargon where possible. Consider the reporter's level of technical expertise when writing the comment.

• **`category`**: This parameter enables categorization of "not a bug" reports. Effective categorization helps identify patterns and areas for improvement. Common categories include:

   *   **UI/UX:** Issues related to the user interface or user experience.
   *   **Configuration:**  Issues stemming from incorrect or unclear configuration options.
   *   **Documentation:**  Issues related to missing or unclear documentation.  Often, "not a bug" reports are simply requests for better documentation.
   *   **Performance:**  Issues related to performance, where the software is functioning as designed but could be optimized. Often requires a Performance analysis.
   *   **Design Choice:**  Issues reflecting a deliberate design decision.
   *   **Feature Request:** Issues that are valid requests for new functionality. These should be linked to a Feature request on Phabricator.
   *   **External Dependency:** Issues caused by limitations or behaviors of external libraries or services.
   *   **Security:** Issues related to security considerations.

• **`reporter`**: While optional, including the reporter's username can be helpful for follow-up communication. It also provides a record of who initially reported the issue. Use the `User:username` syntax to link to the user's page.

• **`resolution`**: This parameter documents how the issue was addressed. Common resolutions include:

   *   **Inform reporter:** The reporter was notified of the decision.
   *   **Document feature:** Documentation was updated to clarify the behavior.
   *   **Close as not a bug:** The issue was closed as a non-bug.
   *   **Redirect to feature request:** The issue was converted into a feature request.
   *   **Duplicate:** The issue was a duplicate of an existing report.

Categorization and Reporting

The `category` parameter is crucial for effective categorization. Consistent use of categories allows for generating reports on the types of non-bug issues being reported. This data can be used to:

• Identify areas where the user interface is confusing.
• Prioritize documentation updates.
• Inform future development planning.
• Improve the overall quality of the software.

Regular reports can be generated to track trends in "not a bug" reports. These reports can reveal common user misunderstandings or areas where the software could be improved to better meet user needs. Consider utilizing tools like MediaWiki API to automate the generation of these reports.

Best Practices

• **Always provide a reason:** Never use the template without specifying a `reason`.
• **Be clear and concise:** Write the `comment` in a clear and understandable manner, avoiding jargon.
• **Consider the reporter:** Write the `comment` with the reporter's level of technical expertise in mind.
• **Use consistent categories:** Maintain a consistent categorization scheme to ensure accurate reporting.
• **Link to relevant documentation:** If the issue is related to documentation, link to the relevant documentation page.
• **Consider a feature request:** If the issue is a valid request for new functionality, create a Feature request on Phabricator and link to it.
• **Inform the reporter:** Whenever possible, inform the reporter of the decision and explain the reasoning. This helps build trust and encourages future contributions.
• **Review before closing:** Double-check the report and the template parameters before closing the issue.
• **Utilize Phabricator integration:** Ensure proper integration with Phabricator for seamless issue tracking.
• **Understand the difference between a bug and a limitation:** A bug is an unintended behavior, while a limitation is a constraint of the system. This distinction is important when using the template.

Related Templates and Pages

• Template:Bug – The template used for reporting actual bugs.
• Template:Duplicate bug - Used for marking duplicate bug reports.
• Template:Feature request - Used for requesting new features.
• Template:Invalid bug - Used for marking invalid bug reports.
• Template:Works as intended – An alternative template with similar functionality.
• MediaWiki:Bug tracking – Information about the bug tracking process.
• Phabricator – The bug tracking system used by the MediaWiki project.
• Help:Reporting bugs – Guidelines for reporting bugs.
• Manual:Configuration – Documentation on configuring MediaWiki.
• Manual:FAQ – Frequently asked questions about MediaWiki.

Advanced Considerations

For experienced users, consider these advanced points:

• **Custom Categories:** You may need to create custom categories to better reflect the specific needs of your project.
• **Scripting:** Automate the application of the template using scripts or bots.
• **API Integration:** Integrate the template with other tools using the MediaWiki API.
• **Trend Analysis:** Perform detailed trend analysis on "not a bug" reports to identify areas for improvement. This could involve Statistical analysis of the data.
• **User Feedback:** Actively solicit user feedback to identify areas where the software is confusing or unintuitive.
• **Usability testing**: Conduct usability testing to identify areas where the user interface can be improved.
• **A/B testing**: Use A/B testing to compare different design options and determine which one performs better.
• **Conversion rate optimization**: Apply conversion rate optimization techniques to improve the user experience and increase user engagement.
• **SEO analysis**: Analyze search engine optimization (SEO) data to identify areas where the software can be improved to attract more users.
• **Competitive analysis**: Conduct competitive analysis to identify best practices and areas where the software can be differentiated.
• **Data mining**: Use data mining techniques to identify patterns and trends in user behavior.
• **Machine learning**: Apply machine learning algorithms to automate tasks and improve the user experience.
• **Big data analytics**: Leverage big data analytics to gain insights into user behavior and identify areas for improvement.
• **Root cause analysis**: Perform root cause analysis to identify the underlying causes of user confusion and frustration.
• **Heuristic evaluation**: Conduct heuristic evaluation to identify usability problems in the user interface.
• **Cognitive walkthrough**: Perform a cognitive walkthrough to simulate how a user would interact with the software.
• **Accessibility testing**: Ensure that the software is accessible to users with disabilities.
• **Localization testing**: Ensure that the software is properly localized for different languages and cultures.
• **Security auditing**: Conduct regular security audits to identify and address potential security vulnerabilities.
• **Penetration testing**: Perform penetration testing to simulate real-world attacks and identify security weaknesses.
• **Risk assessment**: Conduct risk assessments to identify and prioritize potential risks.
• **Compliance auditing**: Ensure that the software complies with relevant regulations and standards.
• **Performance monitoring**: Monitor the performance of the software to identify and address performance bottlenecks.
• **Capacity planning**: Plan for future capacity needs to ensure that the software can handle increased traffic and data volume.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners` template is to clearly and unambiguously communicate that a reported issue is *not* a defect in the code. Mistaking a design decision for a bug wastes developer time and clutters the bug tracking system. This template serves as a signal to both developers and reporters that the issue has been reviewed and determined to be functioning as intended. It's vital to remember that “not a bug” doesn’t mean the reporter’s concern is invalid; it simply means the software is behaving correctly according to its design. Often, these reports are actually Feature requests and should be handled accordingly.

The template also facilitates categorization and reporting on the types of non-bug issues being reported. This data can be valuable for product management and future development planning. Analyzing these reports can reveal common user misunderstandings or areas where the user interface could be improved to better reflect the intended functionality. It's a crucial part of the feedback loop.

Usage

The `

1. Template:Not a bug

is a meta-template used on WikiProject Bugs, and related pages, to mark issues that are *not* bugs in the software, but rather intended behaviors, design choices, or requests for new features. This article details the purpose of the template, its usage, parameters, categorization, and best practices for its application. It is aimed at new contributors to the MediaWiki project and those unfamiliar with the bug reporting process. Understanding and correctly using this template is crucial for maintaining a clean and accurate bug tracking system, facilitating efficient developer workflow, and improving the overall quality of the MediaWiki software.

Purpose and Context

The core purpose of the `` template is to clearly and unambiguously communicate that a reported issue is *not* a defect in the code. Mistaking a design decision for a bug wastes developer time and clutters the bug tracking system. This template serves as a signal to both developers and reporters that the issue has been reviewed and determined to be functioning as intended. It's vital to remember that “not a bug” doesn’t mean the reporter’s concern is invalid; it simply means the software is behaving correctly according to its design. Often, these reports are actually Feature requests and should be handled accordingly.

The template also facilitates categorization and reporting on the types of non-bug issues being reported. This data can be valuable for product management and future development planning. Analyzing these reports can reveal common user misunderstandings or areas where the user interface could be improved to better reflect the intended functionality. It's a crucial part of the feedback loop.

Usage

The `` template is placed on the bug report page itself, typically at the top of the page, after any initial comments or classifications. It immediately signals the resolution to anyone viewing the report. The template is designed to be simple to use, with several optional parameters to provide more context.

Here’s the basic syntax:

```wiki ```

This will display a standard “Not a bug” message. However, to provide more specific information, you can use the following parameters:

• `reason`: This is the most important parameter. It explains *why* the issue is not considered a bug. Common reasons include: "intended behavior", "design choice", "works as designed", "not a bug - documentation update needed", "duplicate", "invalid", and "won't fix". The `reason` parameter should be filled in whenever possible.
• `comment`: Provides additional details about the decision. This is useful for explaining complex design choices or providing context for the reporter.
• `category`: Allows for assigning a specific category to the "not a bug" report. This is helpful for tracking trends and identifying areas where user confusion is common. Examples include "UI/UX", "Configuration", "Performance", "Documentation".
• `reporter`: Used to record the reporter who initially flagged the issue. While not always necessary, it can be helpful for follow-up communication.
• `resolution`: Specifies how the issue was resolved, for example, "Inform reporter", "Document feature", "Close as not a bug".

Example with parameters:

```wiki ```

This would display a message indicating that the issue is an intended behavior, provide a comment explaining the reasoning, categorize it as a UI/UX issue, record the reporter, and indicate the resolution.

Parameters in Detail

Let's delve deeper into each parameter and its appropriate usage.

• **`reason`**: This parameter is *critical*. A vague "Not a bug" without a reason is less helpful than a clear explanation. Consider the following examples:

   *   **Poor:** ``
   *   **Good:** ``

   The `reason` should be concise but informative. Use established terminology where possible.

• **`comment`**: This parameter allows for a more detailed explanation. It is particularly useful when the `reason` is somewhat technical or requires further clarification. The comment should be written in a clear and understandable manner, avoiding jargon where possible. Consider the reporter's level of technical expertise when writing the comment.

• **`category`**: This parameter enables categorization of "not a bug" reports. Effective categorization helps identify patterns and areas for improvement. Common categories include:

   *   **UI/UX:** Issues related to the user interface or user experience.
   *   **Configuration:**  Issues stemming from incorrect or unclear configuration options.
   *   **Documentation:**  Issues related to missing or unclear documentation.  Often, "not a bug" reports are simply requests for better documentation.
   *   **Performance:**  Issues related to performance, where the software is functioning as designed but could be optimized. Often requires a Performance analysis.
   *   **Design Choice:**  Issues reflecting a deliberate design decision.
   *   **Feature Request:** Issues that are valid requests for new functionality. These should be linked to a Feature request on Phabricator.
   *   **External Dependency:** Issues caused by limitations or behaviors of external libraries or services.
   *   **Security:** Issues related to security considerations.

• **`reporter`**: While optional, including the reporter's username can be helpful for follow-up communication. It also provides a record of who initially reported the issue. Use the `User:username` syntax to link to the user's page.

• **`resolution`**: This parameter documents how the issue was addressed. Common resolutions include:

   *   **Inform reporter:** The reporter was notified of the decision.
   *   **Document feature:** Documentation was updated to clarify the behavior.
   *   **Close as not a bug:** The issue was closed as a non-bug.
   *   **Redirect to feature request:** The issue was converted into a feature request.
   *   **Duplicate:** The issue was a duplicate of an existing report.

Categorization and Reporting

The `category` parameter is crucial for effective categorization. Consistent use of categories allows for generating reports on the types of non-bug issues being reported. This data can be used to:

• Identify areas where the user interface is confusing.
• Prioritize documentation updates.
• Inform future development planning.
• Improve the overall quality of the software.

Regular reports can be generated to track trends in "not a bug" reports. These reports can reveal common user misunderstandings or areas where the software could be improved to better meet user needs. Consider utilizing tools like MediaWiki API to automate the generation of these reports.

Best Practices

• **Always provide a reason:** Never use the template without specifying a `reason`.
• **Be clear and concise:** Write the `comment` in a clear and understandable manner, avoiding jargon.
• **Consider the reporter:** Write the `comment` with the reporter's level of technical expertise in mind.
• **Use consistent categories:** Maintain a consistent categorization scheme to ensure accurate reporting.
• **Link to relevant documentation:** If the issue is related to documentation, link to the relevant documentation page.
• **Consider a feature request:** If the issue is a valid request for new functionality, create a Feature request on Phabricator and link to it.
• **Inform the reporter:** Whenever possible, inform the reporter of the decision and explain the reasoning. This helps build trust and encourages future contributions.
• **Review before closing:** Double-check the report and the template parameters before closing the issue.
• **Utilize Phabricator integration:** Ensure proper integration with Phabricator for seamless issue tracking.
• **Understand the difference between a bug and a limitation:** A bug is an unintended behavior, while a limitation is a constraint of the system. This distinction is important when using the template.

Related Templates and Pages

• Template:Bug – The template used for reporting actual bugs.
• Template:Duplicate bug - Used for marking duplicate bug reports.
• Template:Feature request - Used for requesting new features.
• Template:Invalid bug - Used for marking invalid bug reports.
• Template:Works as intended – An alternative template with similar functionality.
• MediaWiki:Bug tracking – Information about the bug tracking process.
• Phabricator – The bug tracking system used by the MediaWiki project.
• Help:Reporting bugs – Guidelines for reporting bugs.
• Manual:Configuration – Documentation on configuring MediaWiki.
• Manual:FAQ – Frequently asked questions about MediaWiki.

Advanced Considerations

For experienced users, consider these advanced points:

• **Custom Categories:** You may need to create custom categories to better reflect the specific needs of your project.
• **Scripting:** Automate the application of the template using scripts or bots.
• **API Integration:** Integrate the template with other tools using the MediaWiki API.
• **Trend Analysis:** Perform detailed trend analysis on "not a bug" reports to identify areas for improvement. This could involve Statistical analysis of the data.
• **User Feedback:** Actively solicit user feedback to identify areas where the software is confusing or unintuitive.
• **Usability testing**: Conduct usability testing to identify areas where the user interface can be improved.
• **A/B testing**: Use A/B testing to compare different design options and determine which one performs better.
• **Conversion rate optimization**: Apply conversion rate optimization techniques to improve the user experience and increase user engagement.
• **SEO analysis**: Analyze search engine optimization (SEO) data to identify areas where the software can be improved to attract more users.
• **Competitive analysis**: Conduct competitive analysis to identify best practices and areas where the software can be differentiated.
• **Data mining**: Use data mining techniques to identify patterns and trends in user behavior.
• **Machine learning**: Apply machine learning algorithms to automate tasks and improve the user experience.
• **Big data analytics**: Leverage big data analytics to gain insights into user behavior and identify areas for improvement.
• **Root cause analysis**: Perform root cause analysis to identify the underlying causes of user confusion and frustration.
• **Heuristic evaluation**: Conduct heuristic evaluation to identify usability problems in the user interface.
• **Cognitive walkthrough**: Perform a cognitive walkthrough to simulate how a user would interact with the software.
• **Accessibility testing**: Ensure that the software is accessible to users with disabilities.
• **Localization testing**: Ensure that the software is properly localized for different languages and cultures.
• **Security auditing**: Conduct regular security audits to identify and address potential security vulnerabilities.
• **Penetration testing**: Perform penetration testing to simulate real-world attacks and identify security weaknesses.
• **Risk assessment**: Conduct risk assessments to identify and prioritize potential risks.
• **Compliance auditing**: Ensure that the software complies with relevant regulations and standards.
• **Performance monitoring**: Monitor the performance of the software to identify and address performance bottlenecks.
• **Capacity planning**: Plan for future capacity needs to ensure that the software can handle increased traffic and data volume.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners` template is placed on the bug report page itself, typically at the top of the page, after any initial comments or classifications. It immediately signals the resolution to anyone viewing the report. The template is designed to be simple to use, with several optional parameters to provide more context.

Here’s the basic syntax:

```wiki

1. Template:Not a bug

is a meta-template used on WikiProject Bugs, and related pages, to mark issues that are *not* bugs in the software, but rather intended behaviors, design choices, or requests for new features. This article details the purpose of the template, its usage, parameters, categorization, and best practices for its application. It is aimed at new contributors to the MediaWiki project and those unfamiliar with the bug reporting process. Understanding and correctly using this template is crucial for maintaining a clean and accurate bug tracking system, facilitating efficient developer workflow, and improving the overall quality of the MediaWiki software.

Purpose and Context

The core purpose of the `` template is to clearly and unambiguously communicate that a reported issue is *not* a defect in the code. Mistaking a design decision for a bug wastes developer time and clutters the bug tracking system. This template serves as a signal to both developers and reporters that the issue has been reviewed and determined to be functioning as intended. It's vital to remember that “not a bug” doesn’t mean the reporter’s concern is invalid; it simply means the software is behaving correctly according to its design. Often, these reports are actually Feature requests and should be handled accordingly.

The template also facilitates categorization and reporting on the types of non-bug issues being reported. This data can be valuable for product management and future development planning. Analyzing these reports can reveal common user misunderstandings or areas where the user interface could be improved to better reflect the intended functionality. It's a crucial part of the feedback loop.

Usage

The `` template is placed on the bug report page itself, typically at the top of the page, after any initial comments or classifications. It immediately signals the resolution to anyone viewing the report. The template is designed to be simple to use, with several optional parameters to provide more context.

Here’s the basic syntax:

```wiki ```

This will display a standard “Not a bug” message. However, to provide more specific information, you can use the following parameters:

• `reason`: This is the most important parameter. It explains *why* the issue is not considered a bug. Common reasons include: "intended behavior", "design choice", "works as designed", "not a bug - documentation update needed", "duplicate", "invalid", and "won't fix". The `reason` parameter should be filled in whenever possible.
• `comment`: Provides additional details about the decision. This is useful for explaining complex design choices or providing context for the reporter.
• `category`: Allows for assigning a specific category to the "not a bug" report. This is helpful for tracking trends and identifying areas where user confusion is common. Examples include "UI/UX", "Configuration", "Performance", "Documentation".
• `reporter`: Used to record the reporter who initially flagged the issue. While not always necessary, it can be helpful for follow-up communication.
• `resolution`: Specifies how the issue was resolved, for example, "Inform reporter", "Document feature", "Close as not a bug".

Example with parameters:

```wiki ```

This would display a message indicating that the issue is an intended behavior, provide a comment explaining the reasoning, categorize it as a UI/UX issue, record the reporter, and indicate the resolution.

Parameters in Detail

Let's delve deeper into each parameter and its appropriate usage.

• **`reason`**: This parameter is *critical*. A vague "Not a bug" without a reason is less helpful than a clear explanation. Consider the following examples:

   *   **Poor:** ``
   *   **Good:** ``

   The `reason` should be concise but informative. Use established terminology where possible.

• **`comment`**: This parameter allows for a more detailed explanation. It is particularly useful when the `reason` is somewhat technical or requires further clarification. The comment should be written in a clear and understandable manner, avoiding jargon where possible. Consider the reporter's level of technical expertise when writing the comment.

• **`category`**: This parameter enables categorization of "not a bug" reports. Effective categorization helps identify patterns and areas for improvement. Common categories include:

   *   **UI/UX:** Issues related to the user interface or user experience.
   *   **Configuration:**  Issues stemming from incorrect or unclear configuration options.
   *   **Documentation:**  Issues related to missing or unclear documentation.  Often, "not a bug" reports are simply requests for better documentation.
   *   **Performance:**  Issues related to performance, where the software is functioning as designed but could be optimized. Often requires a Performance analysis.
   *   **Design Choice:**  Issues reflecting a deliberate design decision.
   *   **Feature Request:** Issues that are valid requests for new functionality. These should be linked to a Feature request on Phabricator.
   *   **External Dependency:** Issues caused by limitations or behaviors of external libraries or services.
   *   **Security:** Issues related to security considerations.

• **`reporter`**: While optional, including the reporter's username can be helpful for follow-up communication. It also provides a record of who initially reported the issue. Use the `User:username` syntax to link to the user's page.

• **`resolution`**: This parameter documents how the issue was addressed. Common resolutions include:

   *   **Inform reporter:** The reporter was notified of the decision.
   *   **Document feature:** Documentation was updated to clarify the behavior.
   *   **Close as not a bug:** The issue was closed as a non-bug.
   *   **Redirect to feature request:** The issue was converted into a feature request.
   *   **Duplicate:** The issue was a duplicate of an existing report.

Categorization and Reporting

The `category` parameter is crucial for effective categorization. Consistent use of categories allows for generating reports on the types of non-bug issues being reported. This data can be used to:

• Identify areas where the user interface is confusing.
• Prioritize documentation updates.
• Inform future development planning.
• Improve the overall quality of the software.

Regular reports can be generated to track trends in "not a bug" reports. These reports can reveal common user misunderstandings or areas where the software could be improved to better meet user needs. Consider utilizing tools like MediaWiki API to automate the generation of these reports.

Best Practices

• **Always provide a reason:** Never use the template without specifying a `reason`.
• **Be clear and concise:** Write the `comment` in a clear and understandable manner, avoiding jargon.
• **Consider the reporter:** Write the `comment` with the reporter's level of technical expertise in mind.
• **Use consistent categories:** Maintain a consistent categorization scheme to ensure accurate reporting.
• **Link to relevant documentation:** If the issue is related to documentation, link to the relevant documentation page.
• **Consider a feature request:** If the issue is a valid request for new functionality, create a Feature request on Phabricator and link to it.
• **Inform the reporter:** Whenever possible, inform the reporter of the decision and explain the reasoning. This helps build trust and encourages future contributions.
• **Review before closing:** Double-check the report and the template parameters before closing the issue.
• **Utilize Phabricator integration:** Ensure proper integration with Phabricator for seamless issue tracking.
• **Understand the difference between a bug and a limitation:** A bug is an unintended behavior, while a limitation is a constraint of the system. This distinction is important when using the template.

Related Templates and Pages

• Template:Bug – The template used for reporting actual bugs.
• Template:Duplicate bug - Used for marking duplicate bug reports.
• Template:Feature request - Used for requesting new features.
• Template:Invalid bug - Used for marking invalid bug reports.
• Template:Works as intended – An alternative template with similar functionality.
• MediaWiki:Bug tracking – Information about the bug tracking process.
• Phabricator – The bug tracking system used by the MediaWiki project.
• Help:Reporting bugs – Guidelines for reporting bugs.
• Manual:Configuration – Documentation on configuring MediaWiki.
• Manual:FAQ – Frequently asked questions about MediaWiki.

Advanced Considerations

For experienced users, consider these advanced points:

• **Custom Categories:** You may need to create custom categories to better reflect the specific needs of your project.
• **Scripting:** Automate the application of the template using scripts or bots.
• **API Integration:** Integrate the template with other tools using the MediaWiki API.
• **Trend Analysis:** Perform detailed trend analysis on "not a bug" reports to identify areas for improvement. This could involve Statistical analysis of the data.
• **User Feedback:** Actively solicit user feedback to identify areas where the software is confusing or unintuitive.
• **Usability testing**: Conduct usability testing to identify areas where the user interface can be improved.
• **A/B testing**: Use A/B testing to compare different design options and determine which one performs better.
• **Conversion rate optimization**: Apply conversion rate optimization techniques to improve the user experience and increase user engagement.
• **SEO analysis**: Analyze search engine optimization (SEO) data to identify areas where the software can be improved to attract more users.
• **Competitive analysis**: Conduct competitive analysis to identify best practices and areas where the software can be differentiated.
• **Data mining**: Use data mining techniques to identify patterns and trends in user behavior.
• **Machine learning**: Apply machine learning algorithms to automate tasks and improve the user experience.
• **Big data analytics**: Leverage big data analytics to gain insights into user behavior and identify areas for improvement.
• **Root cause analysis**: Perform root cause analysis to identify the underlying causes of user confusion and frustration.
• **Heuristic evaluation**: Conduct heuristic evaluation to identify usability problems in the user interface.
• **Cognitive walkthrough**: Perform a cognitive walkthrough to simulate how a user would interact with the software.
• **Accessibility testing**: Ensure that the software is accessible to users with disabilities.
• **Localization testing**: Ensure that the software is properly localized for different languages and cultures.
• **Security auditing**: Conduct regular security audits to identify and address potential security vulnerabilities.
• **Penetration testing**: Perform penetration testing to simulate real-world attacks and identify security weaknesses.
• **Risk assessment**: Conduct risk assessments to identify and prioritize potential risks.
• **Compliance auditing**: Ensure that the software complies with relevant regulations and standards.
• **Performance monitoring**: Monitor the performance of the software to identify and address performance bottlenecks.
• **Capacity planning**: Plan for future capacity needs to ensure that the software can handle increased traffic and data volume.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners ```

This will display a standard “Not a bug” message. However, to provide more specific information, you can use the following parameters:

• `reason`: This is the most important parameter. It explains *why* the issue is not considered a bug. Common reasons include: "intended behavior", "design choice", "works as designed", "not a bug - documentation update needed", "duplicate", "invalid", and "won't fix". The `reason` parameter should be filled in whenever possible.
• `comment`: Provides additional details about the decision. This is useful for explaining complex design choices or providing context for the reporter.
• `category`: Allows for assigning a specific category to the "not a bug" report. This is helpful for tracking trends and identifying areas where user confusion is common. Examples include "UI/UX", "Configuration", "Performance", "Documentation".
• `reporter`: Used to record the reporter who initially flagged the issue. While not always necessary, it can be helpful for follow-up communication.
• `resolution`: Specifies how the issue was resolved, for example, "Inform reporter", "Document feature", "Close as not a bug".

Example with parameters:

```wiki

1. Template:Not a bug

is a meta-template used on WikiProject Bugs, and related pages, to mark issues that are *not* bugs in the software, but rather intended behaviors, design choices, or requests for new features. This article details the purpose of the template, its usage, parameters, categorization, and best practices for its application. It is aimed at new contributors to the MediaWiki project and those unfamiliar with the bug reporting process. Understanding and correctly using this template is crucial for maintaining a clean and accurate bug tracking system, facilitating efficient developer workflow, and improving the overall quality of the MediaWiki software.

Purpose and Context

The core purpose of the `` template is to clearly and unambiguously communicate that a reported issue is *not* a defect in the code. Mistaking a design decision for a bug wastes developer time and clutters the bug tracking system. This template serves as a signal to both developers and reporters that the issue has been reviewed and determined to be functioning as intended. It's vital to remember that “not a bug” doesn’t mean the reporter’s concern is invalid; it simply means the software is behaving correctly according to its design. Often, these reports are actually Feature requests and should be handled accordingly.

The template also facilitates categorization and reporting on the types of non-bug issues being reported. This data can be valuable for product management and future development planning. Analyzing these reports can reveal common user misunderstandings or areas where the user interface could be improved to better reflect the intended functionality. It's a crucial part of the feedback loop.

Usage

The `` template is placed on the bug report page itself, typically at the top of the page, after any initial comments or classifications. It immediately signals the resolution to anyone viewing the report. The template is designed to be simple to use, with several optional parameters to provide more context.

Here’s the basic syntax:

```wiki ```

This will display a standard “Not a bug” message. However, to provide more specific information, you can use the following parameters:

• `reason`: This is the most important parameter. It explains *why* the issue is not considered a bug. Common reasons include: "intended behavior", "design choice", "works as designed", "not a bug - documentation update needed", "duplicate", "invalid", and "won't fix". The `reason` parameter should be filled in whenever possible.
• `comment`: Provides additional details about the decision. This is useful for explaining complex design choices or providing context for the reporter.
• `category`: Allows for assigning a specific category to the "not a bug" report. This is helpful for tracking trends and identifying areas where user confusion is common. Examples include "UI/UX", "Configuration", "Performance", "Documentation".
• `reporter`: Used to record the reporter who initially flagged the issue. While not always necessary, it can be helpful for follow-up communication.
• `resolution`: Specifies how the issue was resolved, for example, "Inform reporter", "Document feature", "Close as not a bug".

Example with parameters:

```wiki ```

This would display a message indicating that the issue is an intended behavior, provide a comment explaining the reasoning, categorize it as a UI/UX issue, record the reporter, and indicate the resolution.

Parameters in Detail

Let's delve deeper into each parameter and its appropriate usage.

• **`reason`**: This parameter is *critical*. A vague "Not a bug" without a reason is less helpful than a clear explanation. Consider the following examples:

   *   **Poor:** ``
   *   **Good:** ``

   The `reason` should be concise but informative. Use established terminology where possible.

• **`comment`**: This parameter allows for a more detailed explanation. It is particularly useful when the `reason` is somewhat technical or requires further clarification. The comment should be written in a clear and understandable manner, avoiding jargon where possible. Consider the reporter's level of technical expertise when writing the comment.

• **`category`**: This parameter enables categorization of "not a bug" reports. Effective categorization helps identify patterns and areas for improvement. Common categories include:

   *   **UI/UX:** Issues related to the user interface or user experience.
   *   **Configuration:**  Issues stemming from incorrect or unclear configuration options.
   *   **Documentation:**  Issues related to missing or unclear documentation.  Often, "not a bug" reports are simply requests for better documentation.
   *   **Performance:**  Issues related to performance, where the software is functioning as designed but could be optimized. Often requires a Performance analysis.
   *   **Design Choice:**  Issues reflecting a deliberate design decision.
   *   **Feature Request:** Issues that are valid requests for new functionality. These should be linked to a Feature request on Phabricator.
   *   **External Dependency:** Issues caused by limitations or behaviors of external libraries or services.
   *   **Security:** Issues related to security considerations.

• **`reporter`**: While optional, including the reporter's username can be helpful for follow-up communication. It also provides a record of who initially reported the issue. Use the `User:username` syntax to link to the user's page.

• **`resolution`**: This parameter documents how the issue was addressed. Common resolutions include:

   *   **Inform reporter:** The reporter was notified of the decision.
   *   **Document feature:** Documentation was updated to clarify the behavior.
   *   **Close as not a bug:** The issue was closed as a non-bug.
   *   **Redirect to feature request:** The issue was converted into a feature request.
   *   **Duplicate:** The issue was a duplicate of an existing report.

Categorization and Reporting

The `category` parameter is crucial for effective categorization. Consistent use of categories allows for generating reports on the types of non-bug issues being reported. This data can be used to:

• Identify areas where the user interface is confusing.
• Prioritize documentation updates.
• Inform future development planning.
• Improve the overall quality of the software.

Regular reports can be generated to track trends in "not a bug" reports. These reports can reveal common user misunderstandings or areas where the software could be improved to better meet user needs. Consider utilizing tools like MediaWiki API to automate the generation of these reports.

Best Practices

• **Always provide a reason:** Never use the template without specifying a `reason`.
• **Be clear and concise:** Write the `comment` in a clear and understandable manner, avoiding jargon.
• **Consider the reporter:** Write the `comment` with the reporter's level of technical expertise in mind.
• **Use consistent categories:** Maintain a consistent categorization scheme to ensure accurate reporting.
• **Link to relevant documentation:** If the issue is related to documentation, link to the relevant documentation page.
• **Consider a feature request:** If the issue is a valid request for new functionality, create a Feature request on Phabricator and link to it.
• **Inform the reporter:** Whenever possible, inform the reporter of the decision and explain the reasoning. This helps build trust and encourages future contributions.
• **Review before closing:** Double-check the report and the template parameters before closing the issue.
• **Utilize Phabricator integration:** Ensure proper integration with Phabricator for seamless issue tracking.
• **Understand the difference between a bug and a limitation:** A bug is an unintended behavior, while a limitation is a constraint of the system. This distinction is important when using the template.

Related Templates and Pages

• Template:Bug – The template used for reporting actual bugs.
• Template:Duplicate bug - Used for marking duplicate bug reports.
• Template:Feature request - Used for requesting new features.
• Template:Invalid bug - Used for marking invalid bug reports.
• Template:Works as intended – An alternative template with similar functionality.
• MediaWiki:Bug tracking – Information about the bug tracking process.
• Phabricator – The bug tracking system used by the MediaWiki project.
• Help:Reporting bugs – Guidelines for reporting bugs.
• Manual:Configuration – Documentation on configuring MediaWiki.
• Manual:FAQ – Frequently asked questions about MediaWiki.

Advanced Considerations

For experienced users, consider these advanced points:

• **Custom Categories:** You may need to create custom categories to better reflect the specific needs of your project.
• **Scripting:** Automate the application of the template using scripts or bots.
• **API Integration:** Integrate the template with other tools using the MediaWiki API.
• **Trend Analysis:** Perform detailed trend analysis on "not a bug" reports to identify areas for improvement. This could involve Statistical analysis of the data.
• **User Feedback:** Actively solicit user feedback to identify areas where the software is confusing or unintuitive.
• **Usability testing**: Conduct usability testing to identify areas where the user interface can be improved.
• **A/B testing**: Use A/B testing to compare different design options and determine which one performs better.
• **Conversion rate optimization**: Apply conversion rate optimization techniques to improve the user experience and increase user engagement.
• **SEO analysis**: Analyze search engine optimization (SEO) data to identify areas where the software can be improved to attract more users.
• **Competitive analysis**: Conduct competitive analysis to identify best practices and areas where the software can be differentiated.
• **Data mining**: Use data mining techniques to identify patterns and trends in user behavior.
• **Machine learning**: Apply machine learning algorithms to automate tasks and improve the user experience.
• **Big data analytics**: Leverage big data analytics to gain insights into user behavior and identify areas for improvement.
• **Root cause analysis**: Perform root cause analysis to identify the underlying causes of user confusion and frustration.
• **Heuristic evaluation**: Conduct heuristic evaluation to identify usability problems in the user interface.
• **Cognitive walkthrough**: Perform a cognitive walkthrough to simulate how a user would interact with the software.
• **Accessibility testing**: Ensure that the software is accessible to users with disabilities.
• **Localization testing**: Ensure that the software is properly localized for different languages and cultures.
• **Security auditing**: Conduct regular security audits to identify and address potential security vulnerabilities.
• **Penetration testing**: Perform penetration testing to simulate real-world attacks and identify security weaknesses.
• **Risk assessment**: Conduct risk assessments to identify and prioritize potential risks.
• **Compliance auditing**: Ensure that the software complies with relevant regulations and standards.
• **Performance monitoring**: Monitor the performance of the software to identify and address performance bottlenecks.
• **Capacity planning**: Plan for future capacity needs to ensure that the software can handle increased traffic and data volume.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners ```

This would display a message indicating that the issue is an intended behavior, provide a comment explaining the reasoning, categorize it as a UI/UX issue, record the reporter, and indicate the resolution.

Parameters in Detail

Let's delve deeper into each parameter and its appropriate usage.

• **`reason`**: This parameter is *critical*. A vague "Not a bug" without a reason is less helpful than a clear explanation. Consider the following examples:

   *   **Poor:** `

1. Template:Not a bug

is a meta-template used on WikiProject Bugs, and related pages, to mark issues that are *not* bugs in the software, but rather intended behaviors, design choices, or requests for new features. This article details the purpose of the template, its usage, parameters, categorization, and best practices for its application. It is aimed at new contributors to the MediaWiki project and those unfamiliar with the bug reporting process. Understanding and correctly using this template is crucial for maintaining a clean and accurate bug tracking system, facilitating efficient developer workflow, and improving the overall quality of the MediaWiki software.

Purpose and Context

The core purpose of the `` template is to clearly and unambiguously communicate that a reported issue is *not* a defect in the code. Mistaking a design decision for a bug wastes developer time and clutters the bug tracking system. This template serves as a signal to both developers and reporters that the issue has been reviewed and determined to be functioning as intended. It's vital to remember that “not a bug” doesn’t mean the reporter’s concern is invalid; it simply means the software is behaving correctly according to its design. Often, these reports are actually Feature requests and should be handled accordingly.

The template also facilitates categorization and reporting on the types of non-bug issues being reported. This data can be valuable for product management and future development planning. Analyzing these reports can reveal common user misunderstandings or areas where the user interface could be improved to better reflect the intended functionality. It's a crucial part of the feedback loop.

Usage

The `` template is placed on the bug report page itself, typically at the top of the page, after any initial comments or classifications. It immediately signals the resolution to anyone viewing the report. The template is designed to be simple to use, with several optional parameters to provide more context.

Here’s the basic syntax:

```wiki ```

This will display a standard “Not a bug” message. However, to provide more specific information, you can use the following parameters:

• `reason`: This is the most important parameter. It explains *why* the issue is not considered a bug. Common reasons include: "intended behavior", "design choice", "works as designed", "not a bug - documentation update needed", "duplicate", "invalid", and "won't fix". The `reason` parameter should be filled in whenever possible.
• `comment`: Provides additional details about the decision. This is useful for explaining complex design choices or providing context for the reporter.
• `category`: Allows for assigning a specific category to the "not a bug" report. This is helpful for tracking trends and identifying areas where user confusion is common. Examples include "UI/UX", "Configuration", "Performance", "Documentation".
• `reporter`: Used to record the reporter who initially flagged the issue. While not always necessary, it can be helpful for follow-up communication.
• `resolution`: Specifies how the issue was resolved, for example, "Inform reporter", "Document feature", "Close as not a bug".

Example with parameters:

```wiki ```

This would display a message indicating that the issue is an intended behavior, provide a comment explaining the reasoning, categorize it as a UI/UX issue, record the reporter, and indicate the resolution.

Parameters in Detail

Let's delve deeper into each parameter and its appropriate usage.

• **`reason`**: This parameter is *critical*. A vague "Not a bug" without a reason is less helpful than a clear explanation. Consider the following examples:

   *   **Poor:** ``
   *   **Good:** ``

   The `reason` should be concise but informative. Use established terminology where possible.

• **`comment`**: This parameter allows for a more detailed explanation. It is particularly useful when the `reason` is somewhat technical or requires further clarification. The comment should be written in a clear and understandable manner, avoiding jargon where possible. Consider the reporter's level of technical expertise when writing the comment.

• **`category`**: This parameter enables categorization of "not a bug" reports. Effective categorization helps identify patterns and areas for improvement. Common categories include:

   *   **UI/UX:** Issues related to the user interface or user experience.
   *   **Configuration:**  Issues stemming from incorrect or unclear configuration options.
   *   **Documentation:**  Issues related to missing or unclear documentation.  Often, "not a bug" reports are simply requests for better documentation.
   *   **Performance:**  Issues related to performance, where the software is functioning as designed but could be optimized. Often requires a Performance analysis.
   *   **Design Choice:**  Issues reflecting a deliberate design decision.
   *   **Feature Request:** Issues that are valid requests for new functionality. These should be linked to a Feature request on Phabricator.
   *   **External Dependency:** Issues caused by limitations or behaviors of external libraries or services.
   *   **Security:** Issues related to security considerations.

• **`reporter`**: While optional, including the reporter's username can be helpful for follow-up communication. It also provides a record of who initially reported the issue. Use the `User:username` syntax to link to the user's page.

• **`resolution`**: This parameter documents how the issue was addressed. Common resolutions include:

   *   **Inform reporter:** The reporter was notified of the decision.
   *   **Document feature:** Documentation was updated to clarify the behavior.
   *   **Close as not a bug:** The issue was closed as a non-bug.
   *   **Redirect to feature request:** The issue was converted into a feature request.
   *   **Duplicate:** The issue was a duplicate of an existing report.

Categorization and Reporting

The `category` parameter is crucial for effective categorization. Consistent use of categories allows for generating reports on the types of non-bug issues being reported. This data can be used to:

• Identify areas where the user interface is confusing.
• Prioritize documentation updates.
• Inform future development planning.
• Improve the overall quality of the software.

Regular reports can be generated to track trends in "not a bug" reports. These reports can reveal common user misunderstandings or areas where the software could be improved to better meet user needs. Consider utilizing tools like MediaWiki API to automate the generation of these reports.

Best Practices

• **Always provide a reason:** Never use the template without specifying a `reason`.
• **Be clear and concise:** Write the `comment` in a clear and understandable manner, avoiding jargon.
• **Consider the reporter:** Write the `comment` with the reporter's level of technical expertise in mind.
• **Use consistent categories:** Maintain a consistent categorization scheme to ensure accurate reporting.
• **Link to relevant documentation:** If the issue is related to documentation, link to the relevant documentation page.
• **Consider a feature request:** If the issue is a valid request for new functionality, create a Feature request on Phabricator and link to it.
• **Inform the reporter:** Whenever possible, inform the reporter of the decision and explain the reasoning. This helps build trust and encourages future contributions.
• **Review before closing:** Double-check the report and the template parameters before closing the issue.
• **Utilize Phabricator integration:** Ensure proper integration with Phabricator for seamless issue tracking.
• **Understand the difference between a bug and a limitation:** A bug is an unintended behavior, while a limitation is a constraint of the system. This distinction is important when using the template.

Related Templates and Pages

• Template:Bug – The template used for reporting actual bugs.
• Template:Duplicate bug - Used for marking duplicate bug reports.
• Template:Feature request - Used for requesting new features.
• Template:Invalid bug - Used for marking invalid bug reports.
• Template:Works as intended – An alternative template with similar functionality.
• MediaWiki:Bug tracking – Information about the bug tracking process.
• Phabricator – The bug tracking system used by the MediaWiki project.
• Help:Reporting bugs – Guidelines for reporting bugs.
• Manual:Configuration – Documentation on configuring MediaWiki.
• Manual:FAQ – Frequently asked questions about MediaWiki.

Advanced Considerations

For experienced users, consider these advanced points:

• **Custom Categories:** You may need to create custom categories to better reflect the specific needs of your project.
• **Scripting:** Automate the application of the template using scripts or bots.
• **API Integration:** Integrate the template with other tools using the MediaWiki API.
• **Trend Analysis:** Perform detailed trend analysis on "not a bug" reports to identify areas for improvement. This could involve Statistical analysis of the data.
• **User Feedback:** Actively solicit user feedback to identify areas where the software is confusing or unintuitive.
• **Usability testing**: Conduct usability testing to identify areas where the user interface can be improved.
• **A/B testing**: Use A/B testing to compare different design options and determine which one performs better.
• **Conversion rate optimization**: Apply conversion rate optimization techniques to improve the user experience and increase user engagement.
• **SEO analysis**: Analyze search engine optimization (SEO) data to identify areas where the software can be improved to attract more users.
• **Competitive analysis**: Conduct competitive analysis to identify best practices and areas where the software can be differentiated.
• **Data mining**: Use data mining techniques to identify patterns and trends in user behavior.
• **Machine learning**: Apply machine learning algorithms to automate tasks and improve the user experience.
• **Big data analytics**: Leverage big data analytics to gain insights into user behavior and identify areas for improvement.
• **Root cause analysis**: Perform root cause analysis to identify the underlying causes of user confusion and frustration.
• **Heuristic evaluation**: Conduct heuristic evaluation to identify usability problems in the user interface.
• **Cognitive walkthrough**: Perform a cognitive walkthrough to simulate how a user would interact with the software.
• **Accessibility testing**: Ensure that the software is accessible to users with disabilities.
• **Localization testing**: Ensure that the software is properly localized for different languages and cultures.
• **Security auditing**: Conduct regular security audits to identify and address potential security vulnerabilities.
• **Penetration testing**: Perform penetration testing to simulate real-world attacks and identify security weaknesses.
• **Risk assessment**: Conduct risk assessments to identify and prioritize potential risks.
• **Compliance auditing**: Ensure that the software complies with relevant regulations and standards.
• **Performance monitoring**: Monitor the performance of the software to identify and address performance bottlenecks.
• **Capacity planning**: Plan for future capacity needs to ensure that the software can handle increased traffic and data volume.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners`

   *   **Good:** `

1. Template:Not a bug

is a meta-template used on WikiProject Bugs, and related pages, to mark issues that are *not* bugs in the software, but rather intended behaviors, design choices, or requests for new features. This article details the purpose of the template, its usage, parameters, categorization, and best practices for its application. It is aimed at new contributors to the MediaWiki project and those unfamiliar with the bug reporting process. Understanding and correctly using this template is crucial for maintaining a clean and accurate bug tracking system, facilitating efficient developer workflow, and improving the overall quality of the MediaWiki software.

Purpose and Context

The core purpose of the `` template is to clearly and unambiguously communicate that a reported issue is *not* a defect in the code. Mistaking a design decision for a bug wastes developer time and clutters the bug tracking system. This template serves as a signal to both developers and reporters that the issue has been reviewed and determined to be functioning as intended. It's vital to remember that “not a bug” doesn’t mean the reporter’s concern is invalid; it simply means the software is behaving correctly according to its design. Often, these reports are actually Feature requests and should be handled accordingly.

The template also facilitates categorization and reporting on the types of non-bug issues being reported. This data can be valuable for product management and future development planning. Analyzing these reports can reveal common user misunderstandings or areas where the user interface could be improved to better reflect the intended functionality. It's a crucial part of the feedback loop.

Usage

The `` template is placed on the bug report page itself, typically at the top of the page, after any initial comments or classifications. It immediately signals the resolution to anyone viewing the report. The template is designed to be simple to use, with several optional parameters to provide more context.

Here’s the basic syntax:

```wiki ```

This will display a standard “Not a bug” message. However, to provide more specific information, you can use the following parameters:

• `reason`: This is the most important parameter. It explains *why* the issue is not considered a bug. Common reasons include: "intended behavior", "design choice", "works as designed", "not a bug - documentation update needed", "duplicate", "invalid", and "won't fix". The `reason` parameter should be filled in whenever possible.
• `comment`: Provides additional details about the decision. This is useful for explaining complex design choices or providing context for the reporter.
• `category`: Allows for assigning a specific category to the "not a bug" report. This is helpful for tracking trends and identifying areas where user confusion is common. Examples include "UI/UX", "Configuration", "Performance", "Documentation".
• `reporter`: Used to record the reporter who initially flagged the issue. While not always necessary, it can be helpful for follow-up communication.
• `resolution`: Specifies how the issue was resolved, for example, "Inform reporter", "Document feature", "Close as not a bug".

Example with parameters:

```wiki ```

This would display a message indicating that the issue is an intended behavior, provide a comment explaining the reasoning, categorize it as a UI/UX issue, record the reporter, and indicate the resolution.

Parameters in Detail

Let's delve deeper into each parameter and its appropriate usage.

• **`reason`**: This parameter is *critical*. A vague "Not a bug" without a reason is less helpful than a clear explanation. Consider the following examples:

   *   **Poor:** ``
   *   **Good:** ``

   The `reason` should be concise but informative. Use established terminology where possible.

• **`comment`**: This parameter allows for a more detailed explanation. It is particularly useful when the `reason` is somewhat technical or requires further clarification. The comment should be written in a clear and understandable manner, avoiding jargon where possible. Consider the reporter's level of technical expertise when writing the comment.

• **`category`**: This parameter enables categorization of "not a bug" reports. Effective categorization helps identify patterns and areas for improvement. Common categories include:

   *   **UI/UX:** Issues related to the user interface or user experience.
   *   **Configuration:**  Issues stemming from incorrect or unclear configuration options.
   *   **Documentation:**  Issues related to missing or unclear documentation.  Often, "not a bug" reports are simply requests for better documentation.
   *   **Performance:**  Issues related to performance, where the software is functioning as designed but could be optimized. Often requires a Performance analysis.
   *   **Design Choice:**  Issues reflecting a deliberate design decision.
   *   **Feature Request:** Issues that are valid requests for new functionality. These should be linked to a Feature request on Phabricator.
   *   **External Dependency:** Issues caused by limitations or behaviors of external libraries or services.
   *   **Security:** Issues related to security considerations.

• **`reporter`**: While optional, including the reporter's username can be helpful for follow-up communication. It also provides a record of who initially reported the issue. Use the `User:username` syntax to link to the user's page.

• **`resolution`**: This parameter documents how the issue was addressed. Common resolutions include:

   *   **Inform reporter:** The reporter was notified of the decision.
   *   **Document feature:** Documentation was updated to clarify the behavior.
   *   **Close as not a bug:** The issue was closed as a non-bug.
   *   **Redirect to feature request:** The issue was converted into a feature request.
   *   **Duplicate:** The issue was a duplicate of an existing report.

Categorization and Reporting

The `category` parameter is crucial for effective categorization. Consistent use of categories allows for generating reports on the types of non-bug issues being reported. This data can be used to:

• Identify areas where the user interface is confusing.
• Prioritize documentation updates.
• Inform future development planning.
• Improve the overall quality of the software.

Regular reports can be generated to track trends in "not a bug" reports. These reports can reveal common user misunderstandings or areas where the software could be improved to better meet user needs. Consider utilizing tools like MediaWiki API to automate the generation of these reports.

Best Practices

• **Always provide a reason:** Never use the template without specifying a `reason`.
• **Be clear and concise:** Write the `comment` in a clear and understandable manner, avoiding jargon.
• **Consider the reporter:** Write the `comment` with the reporter's level of technical expertise in mind.
• **Use consistent categories:** Maintain a consistent categorization scheme to ensure accurate reporting.
• **Link to relevant documentation:** If the issue is related to documentation, link to the relevant documentation page.
• **Consider a feature request:** If the issue is a valid request for new functionality, create a Feature request on Phabricator and link to it.
• **Inform the reporter:** Whenever possible, inform the reporter of the decision and explain the reasoning. This helps build trust and encourages future contributions.
• **Review before closing:** Double-check the report and the template parameters before closing the issue.
• **Utilize Phabricator integration:** Ensure proper integration with Phabricator for seamless issue tracking.
• **Understand the difference between a bug and a limitation:** A bug is an unintended behavior, while a limitation is a constraint of the system. This distinction is important when using the template.

Related Templates and Pages

• Template:Bug – The template used for reporting actual bugs.
• Template:Duplicate bug - Used for marking duplicate bug reports.
• Template:Feature request - Used for requesting new features.
• Template:Invalid bug - Used for marking invalid bug reports.
• Template:Works as intended – An alternative template with similar functionality.
• MediaWiki:Bug tracking – Information about the bug tracking process.
• Phabricator – The bug tracking system used by the MediaWiki project.
• Help:Reporting bugs – Guidelines for reporting bugs.
• Manual:Configuration – Documentation on configuring MediaWiki.
• Manual:FAQ – Frequently asked questions about MediaWiki.

Advanced Considerations

For experienced users, consider these advanced points:

• **Custom Categories:** You may need to create custom categories to better reflect the specific needs of your project.
• **Scripting:** Automate the application of the template using scripts or bots.
• **API Integration:** Integrate the template with other tools using the MediaWiki API.
• **Trend Analysis:** Perform detailed trend analysis on "not a bug" reports to identify areas for improvement. This could involve Statistical analysis of the data.
• **User Feedback:** Actively solicit user feedback to identify areas where the software is confusing or unintuitive.
• **Usability testing**: Conduct usability testing to identify areas where the user interface can be improved.
• **A/B testing**: Use A/B testing to compare different design options and determine which one performs better.
• **Conversion rate optimization**: Apply conversion rate optimization techniques to improve the user experience and increase user engagement.
• **SEO analysis**: Analyze search engine optimization (SEO) data to identify areas where the software can be improved to attract more users.
• **Competitive analysis**: Conduct competitive analysis to identify best practices and areas where the software can be differentiated.
• **Data mining**: Use data mining techniques to identify patterns and trends in user behavior.
• **Machine learning**: Apply machine learning algorithms to automate tasks and improve the user experience.
• **Big data analytics**: Leverage big data analytics to gain insights into user behavior and identify areas for improvement.
• **Root cause analysis**: Perform root cause analysis to identify the underlying causes of user confusion and frustration.
• **Heuristic evaluation**: Conduct heuristic evaluation to identify usability problems in the user interface.
• **Cognitive walkthrough**: Perform a cognitive walkthrough to simulate how a user would interact with the software.
• **Accessibility testing**: Ensure that the software is accessible to users with disabilities.
• **Localization testing**: Ensure that the software is properly localized for different languages and cultures.
• **Security auditing**: Conduct regular security audits to identify and address potential security vulnerabilities.
• **Penetration testing**: Perform penetration testing to simulate real-world attacks and identify security weaknesses.
• **Risk assessment**: Conduct risk assessments to identify and prioritize potential risks.
• **Compliance auditing**: Ensure that the software complies with relevant regulations and standards.
• **Performance monitoring**: Monitor the performance of the software to identify and address performance bottlenecks.
• **Capacity planning**: Plan for future capacity needs to ensure that the software can handle increased traffic and data volume.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners`

   The `reason` should be concise but informative. Use established terminology where possible.

• **`comment`**: This parameter allows for a more detailed explanation. It is particularly useful when the `reason` is somewhat technical or requires further clarification. The comment should be written in a clear and understandable manner, avoiding jargon where possible. Consider the reporter's level of technical expertise when writing the comment.

• **`category`**: This parameter enables categorization of "not a bug" reports. Effective categorization helps identify patterns and areas for improvement. Common categories include:

   *   **UI/UX:** Issues related to the user interface or user experience.
   *   **Configuration:**  Issues stemming from incorrect or unclear configuration options.
   *   **Documentation:**  Issues related to missing or unclear documentation.  Often, "not a bug" reports are simply requests for better documentation.
   *   **Performance:**  Issues related to performance, where the software is functioning as designed but could be optimized. Often requires a Performance analysis.
   *   **Design Choice:**  Issues reflecting a deliberate design decision.
   *   **Feature Request:** Issues that are valid requests for new functionality. These should be linked to a Feature request on Phabricator.
   *   **External Dependency:** Issues caused by limitations or behaviors of external libraries or services.
   *   **Security:** Issues related to security considerations.

• **`reporter`**: While optional, including the reporter's username can be helpful for follow-up communication. It also provides a record of who initially reported the issue. Use the `User:username` syntax to link to the user's page.

• **`resolution`**: This parameter documents how the issue was addressed. Common resolutions include:

   *   **Inform reporter:** The reporter was notified of the decision.
   *   **Document feature:** Documentation was updated to clarify the behavior.
   *   **Close as not a bug:** The issue was closed as a non-bug.
   *   **Redirect to feature request:** The issue was converted into a feature request.
   *   **Duplicate:** The issue was a duplicate of an existing report.

Categorization and Reporting

The `category` parameter is crucial for effective categorization. Consistent use of categories allows for generating reports on the types of non-bug issues being reported. This data can be used to:

• Identify areas where the user interface is confusing.
• Prioritize documentation updates.
• Inform future development planning.
• Improve the overall quality of the software.

Regular reports can be generated to track trends in "not a bug" reports. These reports can reveal common user misunderstandings or areas where the software could be improved to better meet user needs. Consider utilizing tools like MediaWiki API to automate the generation of these reports.

Best Practices

• **Always provide a reason:** Never use the template without specifying a `reason`.
• **Be clear and concise:** Write the `comment` in a clear and understandable manner, avoiding jargon.
• **Consider the reporter:** Write the `comment` with the reporter's level of technical expertise in mind.
• **Use consistent categories:** Maintain a consistent categorization scheme to ensure accurate reporting.
• **Link to relevant documentation:** If the issue is related to documentation, link to the relevant documentation page.
• **Consider a feature request:** If the issue is a valid request for new functionality, create a Feature request on Phabricator and link to it.
• **Inform the reporter:** Whenever possible, inform the reporter of the decision and explain the reasoning. This helps build trust and encourages future contributions.
• **Review before closing:** Double-check the report and the template parameters before closing the issue.
• **Utilize Phabricator integration:** Ensure proper integration with Phabricator for seamless issue tracking.
• **Understand the difference between a bug and a limitation:** A bug is an unintended behavior, while a limitation is a constraint of the system. This distinction is important when using the template.

Related Templates and Pages

• Template:Bug – The template used for reporting actual bugs.
• Template:Duplicate bug - Used for marking duplicate bug reports.
• Template:Feature request - Used for requesting new features.
• Template:Invalid bug - Used for marking invalid bug reports.
• Template:Works as intended – An alternative template with similar functionality.
• MediaWiki:Bug tracking – Information about the bug tracking process.
• Phabricator – The bug tracking system used by the MediaWiki project.
• Help:Reporting bugs – Guidelines for reporting bugs.
• Manual:Configuration – Documentation on configuring MediaWiki.
• Manual:FAQ – Frequently asked questions about MediaWiki.

Advanced Considerations

For experienced users, consider these advanced points:

• **Custom Categories:** You may need to create custom categories to better reflect the specific needs of your project.
• **Scripting:** Automate the application of the template using scripts or bots.
• **API Integration:** Integrate the template with other tools using the MediaWiki API.
• **Trend Analysis:** Perform detailed trend analysis on "not a bug" reports to identify areas for improvement. This could involve Statistical analysis of the data.
• **User Feedback:** Actively solicit user feedback to identify areas where the software is confusing or unintuitive.
• **Usability testing**: Conduct usability testing to identify areas where the user interface can be improved.
• **A/B testing**: Use A/B testing to compare different design options and determine which one performs better.
• **Conversion rate optimization**: Apply conversion rate optimization techniques to improve the user experience and increase user engagement.
• **SEO analysis**: Analyze search engine optimization (SEO) data to identify areas where the software can be improved to attract more users.
• **Competitive analysis**: Conduct competitive analysis to identify best practices and areas where the software can be differentiated.
• **Data mining**: Use data mining techniques to identify patterns and trends in user behavior.
• **Machine learning**: Apply machine learning algorithms to automate tasks and improve the user experience.
• **Big data analytics**: Leverage big data analytics to gain insights into user behavior and identify areas for improvement.
• **Root cause analysis**: Perform root cause analysis to identify the underlying causes of user confusion and frustration.
• **Heuristic evaluation**: Conduct heuristic evaluation to identify usability problems in the user interface.
• **Cognitive walkthrough**: Perform a cognitive walkthrough to simulate how a user would interact with the software.
• **Accessibility testing**: Ensure that the software is accessible to users with disabilities.
• **Localization testing**: Ensure that the software is properly localized for different languages and cultures.
• **Security auditing**: Conduct regular security audits to identify and address potential security vulnerabilities.
• **Penetration testing**: Perform penetration testing to simulate real-world attacks and identify security weaknesses.
• **Risk assessment**: Conduct risk assessments to identify and prioritize potential risks.
• **Compliance auditing**: Ensure that the software complies with relevant regulations and standards.
• **Performance monitoring**: Monitor the performance of the software to identify and address performance bottlenecks.
• **Capacity planning**: Plan for future capacity needs to ensure that the software can handle increased traffic and data volume.

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners