A bug was opened, fixed, verified and closed. A month later, it showed up again in a subsequent version after several iterations without any regression.
Provided the bug characteristics are the same, would you reopen the existing bug ID or open a new one with a link to the closed bug?
Characteristics do not equal causes. The new bug could have a different underlying reason, even though it appears to be the same. So, open a new bug and point it to the old one to help the developer.
If it was verified and closed, and worked for a while, and then appeared again after something was changed, then it's not the same bug. It may manifest itself similarly as the old bug did, but its cause may well be different. So it's not the same bug. So I would open a new one, with a link to the closed bug.
Open a new bug, always. Why? Suppose it turns out to be identical to the previous bug, and you've released the fix for the previous bug. Your release notes will document that "Fix Bug XXX." From the point of view of issue tracking and making the release notes clearer, it is preferable to refer to the new bug "Fix Bug XXX+1 (which was similar in cause and effect to Bug XXX)" rather than to say "Fix Bug XXX (Again)" or something similar.
Generally speaking, open a new bug.
However, if you are allowed to do some investigation first, I would check your history in source code.
If you work in a team environment, somebody may have old code on their system (i.e., they didn't do a Get Latest after the original fix was checked in), made changes, and then checked in without doing a diff. Bad practice, sure, but it happens "all the time."
Looking at the history of the file(s) where the bug was fixed will quickly confirm or eliminate that as a possibility.
I agree with the previous posters' suggestion to open a new bug since it may not end up being the same root cause.
My further recommendation would be to ensure you're always adding unit and integration tests that cover the bug so that in future versions you catch the problem right away before it goes out to your clients. Nothing looks worse to a client then seeing the same bug come back.
Not the best analogy - Just because the symptoms of two people are the same, it does not mean that the disease/cause of disease is the same.
A software bug is an error, flaw, failure or fault in a computer program or system that causes it to produce an incorrect or unexpected result, or to behave in unintended ways. Most bugs arise from.....
A bug is a flaw in code and it has symptoms/effects. A bug is not the symptom. A bug is the error in the code. Just because the symptoms are the same, it does not necessarily mean that the same flaw is causing the symptoms.
My understanding is that you should re-open a bug when you know for sure that a bug is caused due to the same piece of code. This could happen when the code behaves correctly in all testing scenarios/test cases, but does not in a new test case or test case you did not think about earlier. This kind of scenario might not be common.
The other scenario is that the same symptoms are caused by new flaws i.e new bugs in other parts of the same code or even in other systems that affect that code.
So, the safest bet is to open a new bug when same symptoms occur. If you see that the same old code is responsible for the bug, then close the new bug and re-open the old bug. If not, then let the new bug remain and link it to the old one.