23 May

How to write an effective bug report

by Maura

One of the most basic skills anyone dealing with software needs, especially testers, is the ability to write an effective bug report. I’m sure when you first see “bug report” you think it only matters for testers but, trust me, this skill is a very necessary skill for just about everyone. Unfortunately, it’s also a skill that is either undeveloped or underdeveloped in probably 90% of the people I deal with, even technical professionals. Sad but true. I place a lot of the blame for this lack of knowledge and skill on the fact that no one ever seems to teach what a good bug report should contain.

After encountering yet more “bug reports” in my bug database at work today that were completely unactionable because they didn’t include even the most basic information I needed to have in order to start investigations, I decided to publish my own little guide to effective bug reports.

Note that there are multiple pseudonyms for “bug” in use around the industry but I’m just keeping it simple here. Use whatever pseudonym makes you happy. Also note that there are many, many ways of tracking bug reports and a lot of them require that the person filing the bug report fill out information in addition to what I have talked about below. This varies so much by system, team, etc. that I can’t cover them all, but the basics listed below will get you 90% of the way to a useful, actionable, clear bug report. I’m not going to address severity, priority, etc. as those are constructs put on top of bug reports in order to further classify them.

The Purpose of a Bug Report

The purpose of a bug report is to give as much information on a bug as necessary to allow the bug report recipient to investigate the issue and help you to resolve it. That’s it, really, but what I consistently see people doing is forgetting that phrase “as much information on a bug as necessary” and just saying something like “I tried this and it didn’t work.” or “This broke.” These are completely useless bug reports as they contain no details that would even allow someone to begin an investigation. In fact, they aren’t even bug reports – they are just complaints.

Note that I don’t say “all information” because there will be information that does not need to be in the bug report. Typically bugs are not caused by things like what material your desk is made of (as an extreme example) so you do have to exercise some filtering.

Basic Bug Information

All bug reports should include the following information, no matter how they are filed (bug database, email, contact form, etc).

Descriptive Title
The title is the first thing the investigator will see, it’s the most visible and usually one of the easiest to search for. This is your prime area for key information and to clearly state what the bug is. The title should be concise but contain any unique information that may get quick action or allow the investigator to relate your bug to other known issues or reports. Consider these two examples of bug titles:

  1. “MyApplication crashes when USB is plugged in.”
  2. “MyApplication fails with error 1234567 on MyOSv1 when MyCamera is plugged in via USB.”

Notice that the second title gives a lot more information right up front? The error code, the camera make, the OS, etc are all immediately present and can be searched for. The title concisely explains what happens, in what environment and when. You do have to work within any character limits imposed but a great title is a huge help.

There is always some argument when I tell people that I include a statement of impact in my basic bug information list but it makes a big difference in getting a bug fixed if the impact it has is clearly understood up front. Impact can be as minor as a bug that causes the screen to flicker briefly or as major as a system crash and data destruction. Think about what impact the failure itself has and then what impact the steps to recover have and clearly state them for the investigator. You may even know impacts that the investigator doesn’t but should know in order to appropriately classify and prioritize the bug.

I write impact statements like:

Impact: Unable to use MyCamera’s USB download with its OEM supplied software with MyApplication running. I have to manually quit MyApplication before plugging in MyCamera. Recovering from the MyApplication crash requires a system reboot.

Clear Repro Steps
Repro steps are what the investigator will use to try to reproduce your bug for investigation and that means they need to be correct, complete and sequential. I strongly favor these are a numbered list of instructions similar to those shown below:

Repro Steps:

  1. Start MyApplication
  2. Plug USB cable into system and MyCamera usb ports
  3. Turn camera power on.

The repro steps should be free from anything that doesn’t really pertain to the bug so, for example, unless the type of user mattered, I wouldn’t bother saying which user and what security level that user has. In software testing, a goal is always to reduce the repro steps down to the minimum needed to cause the bug to occur. If there is more than one way to get a bug to repro, then I typically use the steps for the shortest or most basic repro scenario. If you have to have a particular state before the bug will occur, that goes at the top of the Repro Steps. So you may start with something like “System needs to be freshly rebooted.” or similar.

Expected Result
Including an expected result in your bug report will help the investigator to determine whether your expectations are accurate. You can be expecting something to happen that won’t because it’s not included in the design or you could be correct in your expectations. Either way, a clear statement of what you expect should always be included. To expand on the sample I started with, I’d include an expected result of:

Expected Result: MyCamera software will autolaunch and I will be asked if I want to download the pictures off MyCamera.

Actual Result
This is where you state what actually happened in as much detail as you can. Just like in the title, this is not the place for “it crashed” but rather a place to tell the investigator whatever you can about what happened when the bug occurred.

Actual Result: MyApplication crashed with a Windows error 1234567. MyCamera software never launched and MyCamera was listed as an unrecognized device.

Each part of this result can give the investigator a clue as to what happened, so they are all worth including. Even if what happens is as seemingly simple as “no device was recognized” or “software did not autolaunch”, you should always have this Actual Result section.

Environment Information
This is an area for you to list the specifics of the environment in which the bug occurred. How much detail you go into depends on what you are reporting a bug on, but some of the common ones are:


  • Operating System and Version
  • Processor Architecture
  • Affected Product Versions and Build #s
  • Browser and Version

If your bug has nothing to do with a browser, you probably don’t need to list the browser. You may need to add in specific information that matter to your particular bug like hardware versions, drivers, etc.

The last section I always have as part of my Basic Bug Information is a section for notes. This is the place to list whatever solutions you’ve tried and what happened, a place to list if the bug occurs when a different repro step set is carried out. You can list any guesses as to what might be causing it to help out the investigator. If you have any log files, screenshots, etc, you should indicate so here and attach them if you have a way to do so. If there is no way to attach them, indicate you have them available if needed. If you have discovered your bug only occurs if you do things one way but not a very similar but different way, indicate that here. Try to make it as easy to read and understand as possible and break it into coherent paragraphs.


Writing an effective bug report is a skill everyone should develop to some extent but it’s critical for software professionals.

Below is a quick snapshot of my Basic Bug Information list that I’ve used in software testing for more than a decade and still use as a technical writer. I’m formatting it as code so you should be able to copy and paste it easily.



Repro Steps:

Expected Result:

Actual Result:



19 August

Congratulations to 2010 Pask award Winners Elisabeth Hendrickson, and Liz Keogh!

by Chuck

I could not be happier to see these find ladies recognized for their work. And as a ‘tester’ myself it’s also fantastic to see two other very ‘test’ oriented folks recognized for their excellent work.

For those not familiar with it, the Gordon Pask Award is intended to bring greater visibility and recognition to members of the Agile community, for recent contributions to Agile practice which deserve to be more widespread.

The Gordon Pask Award recognizes two people whose recent contributions to Agile Practice make them, in the opinion of the Award Committee, people others in the field should emulate. In order that people might emulate them, the Agile Alliance will award each recipient a grant of USD 5000 to fund their work and help them gain additional exposure. In order to grow the next generation of Agile thought leaders, the Award is given to people who the selection committee believes have the potential to bring revolutionary, exciting or groundbreaking ideas to the agile community and change the way agilists work.

Elisabeth may be familiar to many of you from her ‘Test Obsessed’ blog and other work. (and if not, you need to go read her blog at your earliest chance, there’s a lot of good content there). She is also a big proponent of ATDD — Acceptance Test Driven Development.

You can read her thoughts in winning the award here

Liz Keogh is often thought of (along with Dan North) as a co-founder of BDD, she’s a driving force behind the JBehave java based BDD tool, as well as promoting and training folks on BDD

Liz’s bog on the award
These two ladies can teach us all a lot about how test works with Agile development teams, and it’s just wonderful to see them recognized like this.

25 June


by Maura van der Linden

(Cross-posted from my personal blog as it’s germaine to testing.)

Last week, in the course of commenting on James Bach’s blog, I explained that I liked to learn by laying my beliefs and understandings in front of others for them to question things I may not have questioned and, in turn, to question them to see if knowledge or views they have fill in something for me. James responded that this was called “transpection.”

It has a name? Who knew?

Transpection basically means to learn by putting yourself in place of another (to quote James’ blog post on transpection). This is different from introspection (contemplation of one’s own thoughts and feelings) and extrospection (examination of things outside oneself). It’s also different than the often-referred to “put yourself in someone else’s shoes” because you need to put yourself in someone else’s brain, really. It’s less role-playing where you imagine what that person might be thinking (which I think would be still be highly subject to your own views) and more based on really asking questions of someone else about a subject you are interested in.

Honestly, this truly fascinated me. I was not only interested in the fact there was a word for this process but the fact there was spurred me into reading and thinking about the process of transpection. As with many things that catch my interest, I mentioned it a few times and James kindly pointed me at a few other definitions of it.

Then James invited me to join him on skype to have him run me through a transpection session with him. This was a really interesting experience – not terribly comfortable in some ways and yet quite eye-opening in others. Now, mind you, this is coming from a person who has experience with James’ personality and does understand what he’s trying to do in advance. I got frustrated once or twice and felt obtuse several times but it was really fascinating to experience it and, at the end, hear what James’ response to the questions he asked me were.

I’ve read James’ list of problems with transpection on his blog and thought I’d give you my views:

  • Feeling interrogated or tortured – I did feel a bit interrogated but wasn’t that part of the point? On the other hand, because I can see what the goal was, I knew repetition of a question/set of questions meant either that I had an interesting view or I really needed to look at my answers. Tortured, no – other than when I could NOT, even to myself, validate a stance I had taken. Time for that stance to go.
  • Being judged – We all judge each other all the time. I expected it but, in return, I was judging my reactions and James’ approach too. It was definitely a two-way street.
  • Being treated like a lab rat – Yep. But I had a psych minor and undergrads are the lab rats of the psych world. So it was familiar ground and I don’t feel demeaned by it at all. I learned and James learned and that’s the point.

What did I learn?

  • I have fallen a bit into a trap of reliance on metrics and my own fixed idea of what a test/test case consist of. This is more limiting than I would have guessed, actually. This is probably rooted, at least in part, in having done test automation recently.
  • My particular order of examination seems to put visual appearance lower on my list than many people would have it. I need to consciously push it further up my list to compensate. This is almost certainly rooted in the fact I have no real visual memory so it can be quite difficult for me to deal with visual appearance and it’s never my default behavior.

I saved our skype session so I can examine it a few more times to see what else I learn from it. I will note that I did experience a bit of James’ excitement when he hears something interesting. In this case it was my mentioning the fact I had no visual memory. The questions were rapid and many but I didn’t interpret it as sharp or angry – just very curious and wanting to gather information.

I will point out that this type of questioning does require that the need to “be right” or “win” be analyzed as well. I suggest that if you go into a transpection session to prove you are right, you will limit the benefits you can get from it. I also think this desire could be at the root of people feeling attacked or offended. Being right is not the point. Learning is the point and, to learn, you need to be willing to examine what you think you know and your views and reassess them in light of new information. If I went into this session with something to prove, I would not have gotten out of it what I did.

After the skype session with James, I ended up thinking more about my lack of visual memory and ended up trying a somewhat clumsy version of it on my husband, Chuck. I asked him questions about how he finds things around the house and remembers where they are. It sounds simple but it can be cause for friction. I thought it might be interesting because he, unlike myself, is highly visual.

  • We both start by looking for an object in its designated “home” if it has one.
  • If it is not in its home or has no home, Chuck pictures where he last saw it and looks for it there.
  • If it is not in its home or has no home, I remember where I last put it and look for it there.
  • If that fails, we both try nearby areas to the one we expected to find the object in.
  • If that fails, we both resort to trying to figure out where the other person would have decided to put in instead and then check there.

It’s a very simple example but it pointed out something interesting to us. It answers the question of why if I cannot find something, Chuck usually can and vice versa. It also points out a symptom of my lack of visual memory. I cannot picture where I saw it. Instead I rely on where it SHOULD be or where *I* put it.

Since then I’ve done a lot of thinking about how I cope with my weird brain wiring and compensate for it, when necessary. I’ll have to write a separate post on that.

22 March

CHM Text Searches – Lesson Learned

by Maura van der Linden

The current project I am working on involves working on the CHM (Microsoft Help Files) for Windows Embedded Standard 7. This was a project underway before I joined the team and it had even changed managers during that time, which always creates at least a bit of chaos.

We just dropped our CHM files to the product team for integration last week and then discovered we had not completely purged the contents of the project’s internal name and prior release same in favor of the final release name. This happened despite having myself and four other people all search the Help for the string. It even happened despite a tool that would automatically check for the strings you tell it to at build time.

After dealing with the aftermath and rebuild/redrop (my boss was out of town), I looked into why this had happened and discovered I had let my tester mindset go to sleep and had not really thought in depth about how the searches were being done and the potential holes in these approaches.

The stage is set by:

  • The tool was checking for the term in the files at build time.
  • The individual searches done ad-hoc were using the search functionality provided in the Help by Windows when reading the CHM file.

The following discoveries were made as we looked into where this failed:

  • The tool does not check the index. Several instances of terms entered into the tool were found in the index.
  • Not all “bad terms” were entered into the tool’s database.
  • The Search functionality in Help does not search the index and no one thought to look there because the index was generated from files thought to be clean.
  • The Search functionality in Help is a regex-base search. All ad hoc searches were done with the same string, but no one thought to look for substrings with use of a wildcard before, after, or both in relation to the “bad string.” This meant no instances where the “bad string” was a substring could be found, though quite a few existed.

It seems obvious now, of course, but it really does help to look at these occurrences and see what the root cause was so that it can be caught in the future. In this case, we took away the following actions for the next release:

  • All terms must be entered in the tool’s database.
  • The CHM must be decompiled and the HTML contents searched for the “bad terms”. This will catch substrings and index occurrences.
  • Ad hoc searching must be done with wildcards and regex to also look for string and substring occurences.

Lesson learned and I paid the price. Both in terms of this instance’s particular issues and in terms of forgetting to look for holes in the process/testing – even if it’s not my job.

15 December

Scrum on a Software Documentation Team

by Maura van der Linden

In April 2009, I changed roles at work from being a tester to being a contract programmer-writer. As many of you know, this is not my first experience with writing or instructional design, but it is my first experience with being an official member of a documentation team.

The product team we work with is using Scrum and when I joined the documentation team, it was advertised as also using Scrum. Only when I joined did I discover that the team was using a mutant form of Scrum + Waterfall that could perhaps best be described as Stuff Flowing Downhill at Great Velocity and With Little Organization. The only real resemblance to Scrum was the daily “huddle” – except it typically lasted a half-hour for a team of four and was more concerned with approaches than purely status.

The first several months were confusing and prone to bouts of frustration. Work was getting done but, while I couldn’t speak for the other team members, I was certainly not signing up for my own deliverables and setting my own timeframe. I was catching things as they were being tossed at me. Since my personality doesn’t allow me to just sit back and not become personally invested in a project, I offered to help move my team more toward proven Scrum practices but my offers were not accepted. Instead we muddled along and I fought back my desire to help :)

Mind you, I do not think this was because of any ill will or evil intent but I think the situation had roots more in the inexperience of the lead that hired me and in the fact that lead did not have training in Scrum. The lead had read a book about Scrum but I’m not sure which. I was the only team member who had done significant reading and investigation of Scrum, let alone taken a class on it.

About three to four months after I joined the team, the lead that hired me resigned and I gained a new lead. This new lead had no experience with Scrum but did have a lot more experience with leading a documentation team and shipping product documentation. He really got tossed into the morass with a team he didn’t know and a project already at risk. Our product team had no idea what we were doing and where we were and thus were (justifiably) nervous. The lead had no idea where we were either and what had or had not been done. There was no plan, there was process documentation beyond some emails and it was a mess. One lead, a team of three contractors and a huge lot of bugs and legacy documentation – it didn’t look good, I admit.

The day I got the email of the change in leadership, I stopped by his office and introduced myself, then told the new lead I had a lot of feedback on the team, the project and our processes that I’d love to share with him whenever he was ready. He just nodded, looking a bit shell-shocked, and said to give him a few days to get a handle on what was going on. It actually took a few weeks but I was able to start feeding him bits of Scrum processes and suggesting changes to help us. After a few months of introducing change, as well as taking a full time job with my team instead of my contract job, we’re now running a much more Scrum process.

We put up a corkboard in the new lead’s office and went with the visibility of notecards and columns for stages of our process – Writing, Initial Edit, Tech Review, Final Edit, Done. Each team member was responsible for moving their cards and the standup was used for real status updates and blocking issues only. No more talking about how to do something or implementations. I took over running the standups and serving as the Scrum Boss to keep the meeting on track. We stuck with one week sprints because we HAD to get and stay on track and because the documentation team needed to learn Scrum. I felt longer than a week’s sprint was too long given the black-hole history of the team members’ deliverables.

I wrote up a process document to send to the product team members so they would know what our dates are and how the documentation process works. This helped to clear up misperceptions and helped them understand what to expect.

Each of our team members began attending the weekly leads meeting that relates to what section of the documentation they are working on. This helped increase visibility and cooperation with the product team members.

The next step took a lot longer than I’d have liked. I had been pushing my lead into the role of Product Owner. He had the best knowledge of the documentation process overall, the best knowledge and access to the product team’s schedules and needs. And he was the boss :) He was really nervous at not knowing exactly where we were, how we were doing, what progress we were making, etc. His reaction to this nervousness was to suggest scrapping Scrum and going back to waterfall but he did realize it wouldn’t work when I pointed out that it would not help at all to make the switch – instead we would have to start over again. We made a pact to give Scrum a chance.

A month had passed without the product backlog being generated by my lead, despite my promptings. I believe, in part, this was because he wasn’t sure what to do but also because he was involved in trying to hire another team member as well as dealing with the other products he still owned as well as mine. In the third week of my being a full time employee again, I took all the information I had on the parts of the documentation project I owned and made a backlog spreadsheet for it. I wrote some assumption at the top, prioritized in batches according to those assumptions, and did a rough cost estimate on each line item. Not surprisingly, I had about twice as much work TO do as I did time to DO it in.

Once my lead had seen the spreadsheet, the lightbulb really came on. He worked with the other two writers to create the same sort of product backlog for their sections. Because we don’t have enough people for true cross-training, we kept the sections separate for now.

The last two days have been the fruits of all that labor. My lead seemed a bit worried at how the message would be received that we were NOT going to get everything done by the release date. My mantra was constantly “better the devil we know” – at least now we knew exactly where we were, could communicate that and could communicate progress. We came up with a plan for the items that would not make the cut as well. Each project team group has been great when presented with our backlog list. This was the transparency they’d been wanting all along.

Right now I’m waiting for the product team to look at the list items and calling out any changes made in the batch prioritizations I’d made. In the meantime, I’m working from the top of the list.

We stopped the sprint board when I was interviewing, the Thanksgiving holidays hit along with a product preview release, and things got out of hand. My lead has already agreed it will be restarted right after the Christmas holidays. In the meantime, people are working from their backlog lists as well and the standups are reporting status from the writers to the lead.

My lead has gained enough time back to be able to do some writing again, instead of only managing. We will be on the same page as the product team and will have set reasonable expectations of what we will produce by ship time. We even have a plan of how to handle the post-release work that must be done.

I’ve not announced it yet but my boss will soon find out about the sprint retrospectives we need to have :)

16 July

A Rant About Documentation

by Maura van der Linden

As both an author and a consumer of technical documentation as well as having some background in instructional design, I have some strong opinions about the role of documentation for a product. Over a decade in testing has also had an effect on how I view that documentation.

The most basic documentation is the help file that ships with the product. In Microsoft products, this is called a .chm (“chum”) file. Yes, I’ve probably thought of my share of bad jokes about that slang, too. I find myself currently involved in cleaning up the previously written .chm file for a new product as well as authoring new content for it and there have been some challenges.

Out of these challenges have come the start of my own personal list of DOs and DON’Ts for technical documentation.

  • DO know your consumer and know HOW they use the product to do their jobs.
  • DON’T sacrifice your reference sections in favor of only user story or scenario-based content.
  • DO use a more conversational voice to make the documentation easier to consume.
  • DO review customer feedback for opportunities to update your documentation to cover problem areas when appropriate.
  • DO produce other documentation besides just the .chm help files.
  • DON’T use the excuse of having other documentation to short-change the help files.
  • DO edit for professional voice and errors.
  • DON’T over-edit and lose technical accuracy in favor of prettiness of language.
  • DO offer tips and make sure gotchas are included.
  • DO make content easily findable and clearly identifiable by the consumers.
  • DO have your content thoroughly reviewed by the product team.
  • DON’T let the process of creating documentation get in the way of doing the right thing for the customer.

My background in shipping products has given me some valuable insight and gives me a solid base on which to work with the product team. I understand what they are talking about and don’t need a lot of hand-holding. They know I take deadlines seriously and am honest with them about where I am on my deliverables.

But I think documentation teams also really need to be able to turn on a dime. Things can change rapidly and you have to be able to roll with those changes.

Processes are required, both within the documentation team and where the documentation team has to interact with the product development team, but you really have to watch for signs that the process may be causing more overhead and pain that it’s solving. When a five minute task takes three days, an email thread of ten or more emails plus several requests being filed…you may have a problem.

You have to keep your eyes on the prize. The prize is excellent documentation to assist your consumers – not how well processes were followed or how many you have. No one will judge your documentation by how many people worked on it, how many processes were followed, who did what tasks or what tools were used to produce it. All consumers care about is how well it meets their needs.

16 April

RubyGems: RDoc Information on Installed Gems

by Maura van der Linden

It can be useful to view the RDoc information for the various gems you may have installed on your local system. RubyGems provides a way to do this by starting up a local RDoc server.

Local Gem Server
To start the server, open a command window on the machine that has RubyGems installed and type:

gem server

Once the you get a message that the server is starting, you can minimize this command window (don’t close it or the server will stop).

Using your browser of choice, navigate to http://localhost:8808.

When you open this page, you will see a list of all the gems you have installed on the local system and each one will have an WWW link that will open the project’s homepage as well as an RDoc link that will open the RDoc information for that particular gem. At the top of the page are three columns: Files, Classes and Methods. I tend to find Classes and Methods the most useful when trying to discover usage and syntax for a gem.

If you click on methods displayed in the RDocs, an small pop-up will open to show you the code relating to the method. This can be even more useful if you are trying to figure out how to use a method.

Missing RDoc Information
There might be a situation where you have a gem installed that does not have RDoc information but you can force RubyGems to generate RDoc information for already installed gems.

gem rdoc --all

This will generate the RDoc information for all installed gems. You can also generate RDoc for select gems only by using:

gem rdoc GEMNAME

11 March

Ruby Gems – Basic Management

by Maura van der Linden

Ruby Gems can be a little interesting to manage, especially to someone as new to it as I am. In the course of my own self-education, I’ve compiled a little list of what I consider the basic commands. Hopefully this will be of some help to others as well.

Gem Sources

To see which gem servers or repositories your installation of RubyGems is using, open a command prompt and type:

gem sources

The system will return with a list of the repositories and caches Ruby is using to look for gems. In the case of my local system, I got back:

C:\>gem sources


Which shows that my system is only looking at RubyForge for its gems right now. This can be useful to know if you get errors that gems cannot be found.

Installing Gems

To install a new gem, you can open a command prompt and type:

gem install gemname

This will install the latest version of the gem gemname from the repository(ies) your local system knows about.

If you have a local copy of the gem and you need to install that particular one, you can open a command prompt, navigate to the directory that contains the local copy and type:

gem install gemname --local

If you need only a particular version of a gem that might not be the latest version you’d get by default, you can open a command prompt and type:

gem install gemname --version #.#.#

This will install version #.#.# of gem gemname.

Uninstalling Gems

Uninstalling a gem can be done by opening a command prompt and typing:

gem uninstall gemname

This will uninstall the gem gemname. If you have more than one version of that gem installed, RubyGems will display a numbered list of the versions and you can enter the number of the version you want to uninstall or choose to uninstall all versions of gem gemname.

Updating Gems

You can update installed gems by opening a command prompt and typing:

gem update gemname

This will update the gem gemname to the latest version in the gem repository RubyGems is pointing to.

Updating the RubyGems System

Sometimes you will need to update the actual RubyGems management system. To do this, open a command prompt and type:

gem update --system

If you are having problems updating your gems or using them, it usually won’t hurt to try to do this update.

Check Gem Dependencies

If you need to know what the dependencies of an installed gem are, you can open a command prompt and type:

gem dependency gemname

This will list the dependencies of the gem gemname.

Gem Help

There is a good amount of help embedded in the RubyGems system. Often you can answer your own questions on how to manipulate your gems using this help. To access the list of commands, open a command prompt and type:

gem help commands

To get help on an individual command, open a command prompt and type:

gem help command

6 March

Come on in, the Watir’s fine!

by Maura van der Linden

This has been an interesting week for me. I am immersing myself in Watir (Web Applications Testing in Ruby), an open-source library for automating web browsers that works with Ruby, an open-source, object-oriented programming language I’m starting to really like it!

This is a great boon to those of us who have to write automation quickly that need to also be maintainable and not cost an arm and a leg to buy tools for. While some tools do exist, they tend to be expensive or brittle – or both.

The one thing I really am discovering is that there is a mixed bag of documentation and a lot of room for better documentation and training materials. Maybe it’s a place I can turn my writing skills.

30 January

Bug Tracking 3: Minimal Bug Report Information

by Maura van der Linden

Bug reports vary greatly in length and complexity depending on your product, corporate culture and needs but there are some fields that I believe are a must for any bug report. A bare minimum, if you will. This happens to be my own list and other testers will have different fields they consider mandatory but I tend toward a bit of minimalism.

A clear and concise title helps everyone. I make it a practice of putting unique information in the title like error codes or exe names. This makes it easier to later search the bug tracking system for duplicates or regressions rather than file a new bug.

A summary of the environment the bug occurs in as it relates to what you are testing. It could be as simple as the operating system or as complex as the os, browser, version of flash, etc.

How important do you think this bug is to fix? This should be important to the overall product and it may be higher priority if it’s blocking other testing or progress.

Product or Feature Area
What product (in a shared tracking system) or what feature area this bug occurred in. This serves to help when deciding who to assign bugs to or what areas of the product need concentrated attention.

Assigned To
This is the current owner of this bug and who is responsible for the next action with it.

Repro Steps
These are the steps, in order, required to reproduce this bug. They should be complete enough that someone unfamiliar with that bug can accurately reproduce it. I recommend a numbered list. If an additional file or script is needed to reproduce the bug, the location of that should be noted here or the file or script attached if the bug tracking system supports it.

This is a clear statement of what the issue is and why this is a bug. This is the place to make a case for this bug to be fixed so customer impact as well as expected behavior should be listed. If the bug is not high priority, that should be listed here as well. This is not a place to try to game the system and artificially cry wolf on bugs that really don’t deserve it.

Opened By
Who opened the bug. This allows questioning of the person, if necessary.

Opened Date
Date the bug was opened. This is useful for determining bug age.

Opened Version
This is the version of the product the bug is being reported for. It tracks what version was tested, no matter the date the bug was filed.

Fixed By
Who fixed the bug.

Fixed Date
Date the bug was fixed.

Fixed Version
Version of the product the fix will appear in. This allows the person verifying the fix to know when to expect it to be fixed instead of guessing.

Closed By
Who verified the bug was fixed.

Closed Date
Date the bug fix was verified.