Write a Bug Report Deve Will Love | IEEE Computer Society
Finding bugs on your website or in your products can be a major headache. Chances are, if you do come across a bug, you want it fixed as quickly as possible.
That’s why writing effective bug reports is crucial. A bug report tells your developer everything they need to know about the bug, where it’s occurring, and how desperately you need it squashed.
We’re going to take a look at why it’s so important to get your bug reports right, and what features you should include making sure your developers can fix the bug quickly and efficiently.
What is a Bug Report?
A bug report is the best way to let a developer know that an issue with a website or a piece of software needs to be fixed. Writing clear and concise bug reports is essential if you want to get any issues that may be affecting your customers resolved quickly.
Bug reports should be specific and should only contain relevant information that will help your developer to understand and ultimately solve the bug you are alerting them to. Including a lot of unnecessary information will only make the process longer.
Bug reports should include enough information to make the bug reproducible wherever possible. If the developer is unable to reproduce the bug, it’s unlikely they’ll be able to fix it easily.
Want More Career-focused News? Subscribe to Build Your Career Newsletter Today!
Why is it Important to Write Effective Bug Reports?
Software or websites that are filled with bugs won’t work as expected, which will lead to users getting frustrated, often abandoning what they were doing without looking back. For e-commerce sites in particular, this can be a problem. As many as 13% of cart abandonments were due to the website being shopped on having errors.
If you want to make sure your website is running smoothly, then quality bug reporting is essential. This improves the experience for your customers and reduces the pressure on your customer service teams.
Developers are often under a great deal of pressure to solve many issues, so the more helpful information you can provide them with, the easier it will be for them to solve your issues quickly. The more quickly your bugs can be fixed, the less interruption your customers will face, and the less negative effects your business will experience.
Features of an Effective Bug Report
In order to make your bug reports effective, you should try to include as much useful information as possible, while omitting any details that aren’t relevant. Here is a checklist of things that all effective bug reports should include.
Title
The title of your bug report should give your developer the basic details they need to know at a glance. It should include a brief description of what the bug is, and where it occurs.
For example, if you find that items added to the shopping cart of your ecommerce store are not displaying the correct price in the basket, you could use the following as your title;
‘Shopping Cart – Items added to cart display incorrect price’
If you’re experiencing issues that cause the FAQ section on your hosted phone system landing page to display incorrectly, you could use this title instead;
‘Hosted Phone System landing page – FAQ section not displaying correctly’
A title such as this will tell your developer exactly where the bug is occurring, and gives them enough information about the issue to identify whether it has already been reported, and merge any duplicate reports if necessary.
Summary
Sometimes a title will not be enough to get across all the relevant information about a bug. In these instances, you can include a short summary to provide additional information that your developer will need.
In the case of our shopping cart example, you could include the date and time the bug occurred, and what specific items you were trying to add to the cart when you noticed it.
Expected vs. Actual Results
In this section, you can get a little more descriptive about what happened when the bug occurred. You should still try and be succinct, however, and only include relevant information.
The expected result is what should have happened when the action was undertaken. The actual result is what actually happened when the action was undertaken.
Including this information lets the developer know the effect of the bug and how different the outcome is to what is expected. It also lets them know the desired outcome when they get to work fixing the bug.
Visual Evidence
Including some visual evidence in your bug report can help your developer to understand exactly where the bug is occurring, and what happens when it does. This could be a screenshot of the webpage, or even some captured video that shows the steps leading up to the bug being triggered.
Make sure that the visual evidence captures any error messages that may be displayed. If it’s not clear exactly where the bug is occurring, you could annotate the picture to better explain the issue.
Steps to Reproduce
By including the steps that need to be taken to reproduce the bug, you can provide the developer with an easy way to see the bug for themselves first hand. This should help give them a better insight into what is causing the bug, and how to go about fixing it.
You could include a numbered list that lays out exactly what steps need to be taken to reproduce the bug, and in what order. This will reduce the time it takes to find and fix the bug. The earlier in development bugs are fixed, the less they cost your business.
Platform/Environment
Some bugs may only occur in specific web browsers, or on certain devices. Including as much information as possible about the environment you were browsing in when you noticed the bug will help the developer when they’re trying to reproduce it and will give them pertinent information to help them fix it.
The information you include about the environment should cover:
- The web browser used, including the version
- The screen size you were using to view the affected web page
- Your operating system
- The zoom level you were using to view the web page
- The pixel ratio
In addition to this information, it’s also a good idea to include the source URL. Knowing the exact web page you were on when the bug occurred will help the developer narrow down what caused it.
Console Logs
If you are monitoring your system and have access to console logs, including them in a bug report will save the developer a lot of time in determining what caused the bug. They will provide the developer with a list of all the errors that occurred on any given web page.
This can be especially helpful to developers when trying to fix bugs that are hard to reproduce, providing them with information that may otherwise be hard to obtain without seeing the bug first hand.
Severity and Priority
Defining the severity of the bug, and how urgently it needs fixing, will help your developer prioritize the most urgent issues.
The severity of the bug is judged by how much it is impacting your customers, and your business.
When testing websites, 20% of bugs are categorized as being of critical or high severity, meaning they caused a failure or impaired system usability. These bugs need to take the highest priority, whereas the 35% of bugs that are deemed as being low severity can be dealt with less urgently, as they cause mainly cosmetic issues.
Additional Information
Finally, you should include any other information that the developer needs to be made aware of.
This could include referencing information, such as a bug number or bug ID, that can be used to identify cases more easily. You could also include information about who is reporting the bug, so the developer knows who to contact should they require any further information.
You could include details of whom the bug report is being assigned to, if you know which developers are responsible for specific components of your website or product. You could also include a due date, letting the developer know when the bug should ideally be fixed.
General Tips and Tricks For Writing Effective Bug Reports
Including all these features in your bug report will ensure your developer has all the necessary information to fix the issues you’re reporting. But there are several other things you should keep in mind when writing a bug report.
Remember to only report one bug in each bug report. It’s much harder for developers to solve bugs if they have to search through reports that have multiple issues detailed. Even if the bugs seem to be related, give each one its own report.
Try to avoid reporting issues more than once. If your company has an issue tracker, check it before submitting a bug report to make sure you’re not duplicating a report that’s already been submitted.
Professional bug trackers are available from third parties, which can help you keep track of which issues have already been reported. There are also templates available if you need a bit of extra assistance compiling your bug reports, in the same way that you may use a web design proposal template.
Write Better Bug Reports
Writing effective bug reports is essential to keeping your website and your products running smoothly and reducing the negative impacts on your customers and your business as much as possible.
Include as much relevant information as you can while keeping out anything superfluous. Make sure bugs can be reproduced, and include all the steps you took to produce the bug yourself.
Let your developers know how severe the problem is and how urgently it needs to be fixed. Then they can focus on the most pressing issues first.
About the Writer
Yauhen Zaremba is the Director of Demand Generation at PandaDoc. He’s been a marketer for 10+ years, and for the last five years, he’s been entirely focused on the electronic signature, proposal, agency contract template, and document management markets. Yauhen has experience speaking at niche conferences, where he enjoys sharing his expertise with other curious marketers. And in his spare time, he is an avid fisherman and takes nearly 20 fishing trips every year.
How to Write a Good Bug Report (With Examples & Templates) | ClickUp
Whether you found a bug after the development team rolled out a new feature or the mobile app broke after a major update, glitches are just a part of owning a digital product. Instead of starting dozens of back-and-forth email threads describing the bug, learn how to write a good bug report. While you’re free to use Jira, Bugzilla, and other bug reporting tools, the meat and potatoes of the report itself still matters.
But how do you write a good bug report, anyway?
Check out this guide for a breakdown of bug reports and why they matter. We’ll even give you a checklist of items to include and step-by-step instructions on how to write a good bug report.
How to Write a Good Bug Report (With Examples & Templates!)
A bug report, also known as an incident or issue report, is a detailed description of a problem someone finds in a software application. Testers and developers use these reports to communicate about defects. Instead of sending an email saying, “Hey, the form on the Contact page looks broken,” the bug report provides in-depth information the development team can use to troubleshoot the bug ASAP. 🐞
The primary purpose of a bug report is to give enough information to the developer so they can fix the problem. It’s not enough to say that something’s broken; it’s about presenting a clear picture of what’s happening. A good bug report speeds up the debugging process and enhances the overall quality assurance and testing process.
Once the bug report goes through, the development and testing teams work to find the root cause of the issue and fix it. They go through something called the defect or bug life cycle, a process that every bug goes through, from discovery to closure. Many tracking systems, like ClickUp, monitor the life cycle status of each bug so you get a high-level view of where everything is at.
Sure, you could skip the bug-tracking process and run everything like the Wild West. But that’s a recipe for broken applications, messy code, and rework—not to mention a negative end-user experience. Bug reports provide relevant information that helps the development team prioritize and tackle the right issues, streamline their workflows, and simplify the entire testing process. Bug reporting tools come with a range of other benefits, too, from better product quality to better collaboration. 🙌
Improve team collaboration
Software bug reports might seem like red tape or bureaucracy, but they’re an important bridge between testers, developers, and project stakeholders. An effective bug report includes the exact steps to reproduce the error, lists actual vs. expected results, and gives environmental details, which developers need to fix the problem. This clarity not only makes everyone’s workday a little bit easier, but it also brings the team together to take care of business fast.
Enhance the user experience
Software bugs can cause all sorts of weird problems for end users. A single issue or error can cause users to leave your platform for good, so taking bug tracking and reporting seriously is in your best interests.
A good software bug report can also provide a systematic, structured way to tackle these errors, ensuring your product is as error-free and user-friendly as possible. If you have a lot of bugs, your ranking system should allow you to rank them by priority so you can address the stickiest issues in the product backlog first.
Create a quality product
Every software has bugs. Product quality comes down to how well and quickly your team manages bugs. Fortunately, detailed bug reports provide insight into your product’s weaknesses so developers can understand its severity and impact. The better they understand the problem, the more targeted and efficient their fixes will be. Effective incident reports also reduce developers’ time clarifying requirements, giving them more time to code.
Streamline the development process
Software development can be tricky from a project management perspective. Instead of going on wild goose chases for bugs that don’t exist, developers consult the report and get right to fixing the issue. Proper bug reporting removes ambiguity and gets everyone on the same page. Good reports won’t entirely eliminate back-and-forths and requests for clarification, but they certainly will cut down unnecessary confusion, ultimately streamlining the development workflow.
Reduce costs
That’s right: Addressing bugs early in the development process can actually reduce costs. The longer you leave a bug unresolved, the more expensive it is to fix it. Effective bug reporting enables early detection, which reduces the cost and effort required to resolve issues.
It’s one thing to write a bug report, but writing a good bug report is an art. Organizations are different, but the best bug reports often include these elements.
Bug ID
You probably have quite a few bugs to manage. Instead of releasing each bug report willy-nilly, assign it a unique bug ID. You can use this identifier for new bug reports in your issue tracking system, making tracking and referencing the right bug easier. This will also come in handy if multiple people experience the same bug.
Title or summary
Give a short, sweet title that provides a snapshot of the main issue. It should be clear enough that anyone understands the nature of the bug at a glance. Don’t put too many extra details here. Distill it down to the main idea and add context or information later in the report.
Priority and severity
Developers have a lot on their plates. Assigning a priority and severity level to each bug report helps them rebalance their workload and address tasks in the right order. The bug priority level indicates the urgency of the fix, while the bug severity reflects the impact the bug will have on the system’s functionality.
Environment details
Maybe an app’s CSS isn’t loading on your machine, but it works fine on a colleague’s MacBook. This is an environmental detail that developers need to know.
Include information about:
- Your operating system: Windows, MacOS, Linux, etc.
- Your browser type and version: Chrome, Firefox, Safari, etc.
- Your hardware
Depending on the product, you might also need to share the software version you’re running and when it was last updated.
Bug description
It’s showtime! Here’s where you provide a detailed description of the bug. Explain how the bug occurred in the application and the impact it has on the user experience or functionality. 📝
Steps to reproduce
Maybe you’re experiencing a bug, but the development team doesn’t see it. It’s a good idea for reporting bugs to provide instructions on how you came across it and how the developers can find it, too. Provide clear, step-by-step bullet points on how to reproduce the bug. If it isn’t reproducible on the developer’s end, it might indicate an issue with your system and not the application, which is why reproduction directions are so important.
Expected vs. actual result
Apps have a lot of moving parts, and developers might not know the function or purpose of everything off the top of their heads. It’s helpful if the developer knows what you expect to happen versus what’s actually going on. Something like, “When I clicked on this link, I expected to be rerouted to the signup page, but I actually got an error.” This is important because it highlights the discrepancy that the developer needs to fix.
Notes and attachments
Sometimes, it’s easier to show instead of tell. Try to include relevant files, like error logs, data files, screenshots, or video recordings. Sometimes, visual proof makes all the difference, so if you need an issue resolved quickly, provide as much evidence as you can.
Learning how to write a bug report comes with a bit of a learning curve. Double-check that your report doesn’t run into any of these common bug report issues.
Vague titles
Generic or vague titles will leave developers scratching their heads. A title like “I found a bug” isn’t specific or helpful. Instead, give a concise summary of what’s actually going on, like “Error message when adding items to cart.”
Incomplete information
Bug reports request certain fields for a reason. Failing to provide details on your operating system, application version, or browser type can hinder the debugging process. If you don’t know the information, take the time to find it. The developer will ask you for this information anyway, so you might as well save everyone some time by submitting this data from the start.
Typos
We aren’t talking about mixing up “their,” “there,” and “they’re.” We mean typos that could potentially change the meaning of what you’re trying to say. This is especially true if you use branded terms or autocorrect on your computer. For example, “text” and “test” are a single letter apart, but mixing up the two terms could lead to confusion.
Ambiguous steps to reproduce
Instructions like “log in to find the bug” isn’t helpful. Remember, the goal is to make the issue reproducible. Nothing is “obvious” or “common sense” here. Don’t make assumptions: Always include step-by-step instructions, even if they seem too basic or simple.
Not checking for duplicates
Is everyone experiencing the same error? If so, there’s a good chance someone already submitted a bug report, and it’s in a developer’s queue. Submitting multiple reports for the same issue slows everyone down, so if you have access to the bug tracking system, check to see if someone has already submitted this request first.
Using subjective language or opinions
Personal opinions like, “This shade of purple is ugly,” aren’t helpful to developers. Personal opinions or pet peeves aren’t the same as actual bugs. Keep your report as factual and precise as possible; everything else is just a red herring that could slow down the development team.
Ignoring feedback or questions
The receiving developer might have questions or comments about your bug report. Instead of submitting it and going about your merry way, make yourself available to interact with the developer. The quicker you answer their questions, the faster they’ll be able to fix the issue.
Improper severity or priority assessment
If you notice a security breach and label it as a low-priority issue, that’s a problem. Consider the real-life consequences that the bug has on the end-user experience. Not being able to log in is a big issue, while small problems like image rendering are a lower priority.
Software teams rely on ClickUp for more than issue tracking and bug reports. It’s an all-in-one project management solution that supports collaboration, brainstorming, and everything in between for technical teams. Manage tasks, Chats, technical documentation, Goals, and more in one place. ClickUp Forms even standardize the bug reporting process, so you don’t have to worry about people getting “creative” with their submissions. 👀
There’s no need to create your bug and issue-tracking workflows from scratch, either. Try the ClickUp Bug & Issue Tracking Template to support cross-functional collaboration with automated forms, customized intake Forms, and flexible views. If you need a little inspiration, see how ClickUp structures its short and sweet bug report Form.
Streamline Software Testing With ClickUp
Software bugs are just a part of digital product development. Learning how to report bugs will arm your developers with more relevant, actionable information that speeds up fixes, minimizes hassle, and improves the user experience.
Writing a solid bug report will get you far, but you still need a system for tracking, managing, and communicating about bugs. That’s where we come in. ClickUp is a solid project management platform that brings IT templates, Forms, tasks, and communications in one place. Stop flipping between multiple tools and bring everything into a truly all-in-one platform with ClickUp. Give it a spin: Create your free ClickUp Workspace now!
Everything you need to stay organized and get work done.
What Is a "Computer Bug," and Where Did the Term Come From?
Quick Links
You've probably heard it before: There's a "bug" in the software, causing something to malfunction or misbehave. What exactly is a computer bug and where did the term come from? We'll explain.
A Bug Is an Unintentional Error in Computer Software
A "computer bug" or "software bug" is a term for an unintentional programming mistake or defect in computer software or hardware. Bugs arise from human error in hardware designs or somewhere in the chain of software tools used to create computer applications, firmware, or operating systems.
In today's software-driven world, bugs are serious business. Almost 20 years ago, the National Institute of Standards and Technology estimated that software bugs cost the U.S. economy almost $60 billion annually (about 0.6% of the GDP in 2002)---a number that has likely increased since then. While accurately quantifying the negative effects of bugs is difficult, it's easy to imagine how malfunctioning software can affect productivity. It can even put lives at risk in the realm of transportation or endanger vital infrastructure like power plants.
Why Do We Call Them Bugs?
The term "bug" predates the invention of computers, and we don't actually know who originally coined the term "bug" to refer to an engineering defect. In written records, historians have traced it back to Thomas Edison in the 1870s at the earliest.
"You were partly correct, I did find a 'bug' in my apparatus, but it was not in the telephone proper. It was of the genus 'callbellum.' The insect appears to find conditions for its existence in all call apparatus of Telephones."
While some take Edison's examples to mean that he coined the term "bug," it's possible that it originated from someone else earlier and that he merely popularized the term among his engineering friends and associates. The Oxford English Dictionary cites an 1889 example related to Edison that describes a bug as a metaphor for an insect crawling into a piece of equipment and making it malfunction, suggesting that a real bug doing just that might have originally inspired the term, similar to the term "fly in the ointment."
Setting the word "bug" aside for a moment, the first known person in history to realize that software may malfunction due to errors in programming was Ada Lovelace. She wrote about the problem way back in 1843 in her commentary about Charles Babbage's Analytical Engine.
In this quote, Lovelace refers to the actual calculating mechanism being error-free in the way that it processes data, but stipulates that the data fed to it by humans (as programmed on cards at the time) could give the machine the wrong instructions and thus produce the wrong results.
What About Grace Hopper's Moth?
For decades, books, magazines, and websites have erroneously reported that the term "bug" was coined by legendary computer scientist Grace Hopper when a moth flew into the relays of the Harvard Mark II computer and caused it to malfunction. As the story goes, she then taped the moth into a logbook and wrote a historical note: "First actual case of bug being found."
"When we were debugging Mark II, it was over in another building, and the windows had no screens on them and we were working on it at night, of course, and all the bugs in the world came in. And, one night she conked out, and we went to look for the bug and found an actual large moth, about four inches wing span, in one of the relays beaten to death, and we took it out and put it in the log book and pasted scotch tape over it, and as far as I know, that's still in the historical log book up at Harvard (we found an actual bug in the computer)."
Hopper found the story amusing because, after frequently hunting down bugs in the computer (as in hardware and software defects), her team had finally found an actual, literal insect inside the computer. Hence the inscription, "First actual case of bug being found."
(As an interesting aside, Hopper describes the Mark IV moth as "beaten to death," likely because of the damage from getting caught within the movement of the computer's electromechanical relays, which suggests the computer continued to function while the moth was in there.)
While the Mark II moth (Let's call him "Mark.") wasn't the first computer bug, it nevertheless persists as a physical and cultural symbol of a very real and difficult problem all programmers struggle with, and it's something we'll all be dealing with for years to come. Now pass me the bug spray, will ya?
How to Write A Bug Report with Examples
What is Bug Report? Why do you need a good bug report?
Bug Report is an important document in STLC that offers various advantages to the testing team. It keeps track of all the defects, multiple bugs, errors, and other discrepancies found during software testing and reports them.
The purpose of this post-testing documentation is to provide information to the concerned team of professionals about the level of bugs encountered during the testing process.
Your software development engineer can be made aware of all the defects and issues present in the software using this type of report. It also lets you figure out what’s wrong with a bug, so you can use the best method to fix it. It also helps you to save your time and money by helping you catch bugs and issues.
Why should you care about good bug explanations?
Here is the point that you need to consider for writing a good, detailed software bug report:
- It acts as a guide to help avoid the same bug in future releases.
- Save time for communication (e-mails, calls).
- Less work for developers (they will do exactly what you want).
- You will have less bottlenecks in the project; bugs will be fixed faster and more efficient way.
There is no exact bug report template, as it depends upon your bug-tracking system. Your template might be different.
However, the following common fields are always needed when you want to write a bug report:
- Bug id/ Title.
- Severity and Priority.
- Description
- Environment
- Steps to reproduce.
- Expected result.
- Actual result.
- Attachments (screenshots, videos, text)
Let’s look at all these bug-tacking components one by one:
1) Title/Bug ID:
Every bug should be given a unique identification number. Bug reporting tools should be unique numbers for the newly raised bugs so we can easily identify the bug.
Examples:
❌ Bad: “I can’t see the product when I again, tyrp it doesn’t.”
- Vague
- Aggressive
- Too wordy
asks for a solution to be implemented.
✅ Good: “CART – New items added to the cart that does not appear”.
- This kind of Title instantly locates the issue (CART)
- It focuses on the actual technical problem.
2) Bug Severity:
Bug severity is a very important factor in the bug report. It describes the effect of the defect on the application’s performance.
- Blocker: This error causes the app to fail.
- Major: A critical error indicates a major change in the business logic.
- Minor: An issue that doesn’t affect the application’s functionality but does affect the expected results.
- Trivial: It does not affect the functionality or operation of the app. It could be a typographical error.
3) Bug Priority:
Following is the general gradation to decide bug priority:
- High: It covers anything which affects the flow or blocks app usage.
- Medium: It adversely affects the user experience.
- Minor: All other errors like (typos, missing icons, layout issues, etc.).
4) Environment:
A Bug can appear in a specific environment and not others. For example, sometimes a bug appears when running the website on Firefox, or an app malfunction only when running on an Android device and working fine on iPhone.
These bug reports can only be identified with cross-browser or cross-device testing. So, when reporting the bug, QAs should be able to specify if the bug should be observed in one or more specific environments.
5) Summary:
However, adding only the Title in the bug report does not serve the purpose. So, if your Title isn’t enough, you can add a short report summary.
Your summary in as few words as possible including when and how the bug occurred. Your Title and bug description should also be used in searches, so you must ensure you have covered important keywords.
Examples:
- Bad: “I was trying to add stuff to the test, and nothing showed up when I did that or clicked on the button.”
- Good: “When I tried adding [PRODUCT] to the shopping cart, but nothing happened when I clicked the ‘add’ button on the specific product overview webpage.”
6) Steps to reproduce:
When reporting a bug, it is important to specify the steps to reproduce it. You should also include actions that may cause the bug. Here, don’t make any generic statements.
Be specific on the steps to follow:
Here, is an example of well-written procedure:
Steps:
- Select product X1.
- Click on Add to cart.
- Click Remove to remove the product from the cart.
7) Expected result:
In bug reports, describing the expected result per the technical task, test case outcomes design, or according to the tester’s opinion is important. All this helps developers to focus on quickly finding needed information.
For example:
Required fields should be highlighted in red after clicking the” Submit” button.
8) Actual result:
As it names suggests, this s field describes the actual effect of the bug. It is very important to write a clear description of the actual result.
For example:
Required fields are highlighted in green color after clicking the “Submit” button.
9) Attachments (screenshots and videos):
In bug reports, it is best practice to attach files to bug reports which makes it easier to perceive information when you need to display it visually:
For example:
- Screenshot: Screenshots can easily elaborate mistakes in the program; s convenient when the bug is highlighted with a specific annotation, circle, or arrow image).
- Video: Sometimes, it is difficult to describe the bug in words, so it’s better to create a video so that developer can rectify the defect in the program).
10) Affected Version:
It is the affected software version where the bug is reported.
11) Fix Version:
It is the software version in which the bug is resolved. So when the QA who reported the bug, checks whether it is fixed, he uses the correct software version.
12) Target version:
The target version where a bug should be targeted to be fixed. So, when the development team works on fixing a bug, they mostly target a particular application version.
13) Date Closed:
It is the date when the bug is closed by the software testing team. Closing a bug is a vital and integral part of software testing.
14) Status:
When a new bug is created, its status should be open. After that, it goes through stages like In Progress, Fixed, Running, Reopen, etc.
Tips for Bug Report Writing
Here are some important tips that you should remember while writing an effective bug report:
- Be specific when creating bug reports. Make sure you don’t include any useless or irrelevant facts.
- You must report the bug immediately as soon as it gets detected.
- Prepare the report in detail to empower the developer to use the facts and the information to debug the issue.
- You should test the same bug occurrence on other similar modules for validation.
- Review the bug report at least once before submitting it.
- You should ensure that the bug report contains the description of only one error.
- Lastly, you should not be afraid to ask the Project Manager for help if you feel unclear about something.
The bug reporting process, performed manually, is now being performed with various bug reporting tools available in the market.
- JIRA
- Zoho Bug Tracker
- Bugzilla
You can check our detailed review of the best bug reporting tool.
Common Problem and Solution while Writing a bug report:
Here are some common problems and their solutions while writing a bug report:
| Bug Report Example | Problem |
|---|---|
| When multiplying 2 by 3, the answer will be positive. | Report the pattern, not an example. |
| The list will be ordered alphabetically when adding a new item to avoid this. | Don’t only describe what’s wrong |
| For example: To being, you will need to open your browser and type the site’s URL. You’ll find the first field, ‘username,’ misspelled. |
Always direct to the point (Never tell the story!). |
| The client’s name in the report is misspelled. Priority: High, Severity: High | Never mix priority and severity. |
| The tax calculation formula is INCORRECT !!?? | Does not use CAPS, red letters, red circles, ‘!’, |
| I don’t think that the home page Ul design is good. | Don’t use your judgment. |
| Example of unclear description: About our discussion today, please do the required action for this page. | Make your description understandable for everyone. |
| The page background should be blue, orange, or green, or you can make it black or white.
This is not good as it is unclear what is needed from the web development and design team |
Minimize the options |
| The tax calculation formula is sometimes not working as expected. | The golden rule: Don’t use the word ‘Sometimes’. |
Example of Bug Report
Here is a small example of a bug report:
[MY ACCOUNT] Underline is displayed when mouse overing on the Update button.
Description: We need to remove the underline when mouse overing on the Update button in My Account section.
Link: http://test.com/mv-account/
Browser/OS: Chrome 25. OSX Yosemite 10.10.2
Steps to reproduce:
1. Go to www.test.com
2. Login via login credentials
3. Navigate to My Account
4. Mouseover on the Update button
Actual result: there is an underline.
Expected Result: no underline.
Login Data: test@test.com / mysecretpass12
Must avoid mistakes in bug report writing
Here are some important mistakes that you should avoid while writing a bug report:
- Don’t write about your dissatisfaction, and never include your personal feelings.
- It annoys people who want to focus on the task when you overload your post with many emoticons.
- Never overload your post with exclamation points; it does not speed up the work.
- Nobody wants to feel offended. It destroys motivation and slows the realization of the issue.
No comments:
Post a Comment