> I'm going to go ahead and guess that the problems discussed were fixed, and I'm closing this bug report. If there's anything more to be worked on here, please send a mail to the debbugs address and we'll reopen the bug report.
I don't think this really qualifies as "ignoring". Having read the last two messages or so, their approach looks totally reasonable to me. Please don't scold maintainers for cleaning up? :(
Assuming the STR is clear, is it the original reporter's responsibility, or the developer's, to confirm if a bug is fixed or not?
It was five years later that someone came along and closed the bug.
After that I’m usually satisfied the bug has been fixed. So I will link the git commit hash of the fix to the bug report and ask the reporter if it fixes the issue their side. If I don’t hear anything back after a week or two I will follow up with a message much like the aforementioned: “closing this ticket because I believe it to be resolved but happy to reopen if you’re still experiencing issues.”
That is the only way I’ve found to manage projects because you either end up closing tickets prematurely and miss bugs, or you end up with tickets open for fixed issues that take time and additional mental overhead to filter out (both of which are a scarce resource when you’re trying to balance open source maintenance with a full time job and a family).
Two weeks might not seem long but I’m always happy to reopen issues. However if users really feel that hard done by this approach then they’re welcome to submit a pull request instead. Or even fork my project and maintain that they way they feel it should be done. Maybe they’ll have more free time than me to filter through historic issues that are now fixed but not closed between their personal lives and coding time.
This tacitly embraces the bugtracker-as-helpdesk/CRM mindset, i.e., the GitHub approach, which is what leads to things getting so chaotic and unwieldy in the first place. It's right in the language—focusing on "their" issue. Both maintainers and users need to approach the bugracker by recognizing that the scope of any given bug report is the bug, and by extension the project, not the bug reporter or maintainer. By the time a bug is being closed, a maintainer should know (at least with some level of confidence—but allowing for them to be wrong) whether the bug is fixed or not—because it should be well-defined. If the maintainer is not able to do this with confidence, it indicates a failure in the practices for handling bugs—and possibly (or "likely", in the case of a typical project hosted on GitHub) muddled scope.
It may be the case that from the user perspective, they're still experiencing some issue, but this doesn't call for the bug being reopened to handle it. Remember, it's not theirs, it's the bug's! If the last report led to a real bug being identified, and it really was fixed, then leave it closed and figure out if it isn't the case that they misidentified the source of the discomfort they were experiencing, and if so, have them attempt to articulate it, then open a new bug for that. Otherwise, you're just treating your bug tracker like a message board but splattering it with state changes of what amounts to your personal TODO list—where "open" and "closed" correspond to whether you've decided you're finished with it or not. Remember not to think of the bug tracker as yours either! It belongs to the project and its bugs. Think of the software as a non-human entity and you as a scientist and its designated caretaker. It's best to think of the bug reporter as a scientist, too—and the elevated expectations and responsibility that comes with it.
It's an observable truth that if you want people to use your software, it's necessary to prioritize pleasantness. It's also practically a logical necessity, unless your user community is comprised of individuals who enjoy being displeased and otherwise frustrated.
Obviously. (Isn't it? Not sure why this explanation is appearing as a reply here. How could the previous comment have been written without a strong understanding that there's distinction? Why would it have been written unless there was a strong belief in the distinction?)
> we still track it until the customer is unblocked
As you should... in some place that isn't the bug tracker. (See "muddled.")
At some point, you have to close things. Chances are they were spurious, have been fixed or made irrelevant (maybe the code no longer exists) or nobody cares.
And if someone does care and it's still an issue, you can reopen. It's not as if you are permanently deleting all the information for the rest of time.
If it's still an issue with our internal customer [0], they can reopen the ticket or open a new one. But we've completely rearchitectured our systems since the ticket was first opened, our internal customer has changed leadership and has had considerable staff turnover, and not a single person has brought it up in our biweekly meetings with our internal customer for ages, so we might as well just close it out.
[0] when I say "customer", I'm talking about a department, not a single individual
In the majority of cases, there's another project that I can move to and I do so as soon as possible.
There are presumably others like me. So when you say it's sustainable, you may not be accounting for the reputational damage it does to your project, which you will almost certainly never be made explicitly aware of because users know it's not worth their time to file bugs.
As an observation, the whole thread is a back-and-forth exchange of a user supplying incidental test cases and the dev fixing them one by one, for months. I'm actually surprised the main emacs maintainer would put up with this - usually formatters and syntax highlighting are handled by user extensions, it's not humanly possible for one person to be an expert in 100+ programming languages and their favored styles. Someone else who is a heavy user of the language could take the time to dive in and probably fix all the formatting issues in one go. Or make a patch to bring in the third-party better-maintained prolog-mode that is mentioned in the discussion.
It is definitely nice that the Emacs maintainers corrected some of these regressions which I explained in this issue with steps to reproduce them. However, the information from 23 Nov 2015 that 2 out of several regressions I had reported in this issue are now believed to be corrected does not solve the other issues I reported in the course of the discussion and which still remain. It is easy to reproduce them with the instructions I posted in case someone is still interested in correcting them. Alternatively, one can simply use the third-party mode which does not have these issues also because I had previously already contributed changes to specifically address some of these issues in that original version of the mode.
The key reason for the divergence between these two versions of the same original mode is that Emacs maintainers prefer to use SMIE-based indentation for the mode, and switching the mode to SMIE in the Emacs trunk introduced the reported regressions. SMIE is an indentation and navigation engine that the Emacs maintainers provide. My impression from the discussion in the cited issue is that SMIE is lacking some of the features that are needed to implement the desired and previously supported indentation and navigation for this particular mode. There may be a way to improve SMIE to support these use cases, it may be quite hard though: I expect that if it were easy, these changes would have been made by the Emacs maintainers to solve the remaining issues too in the last few years.
The second to last post says they believe the issue is fixed, with nobody complaining it isn't fixed for the 5 years after. I guess that doesn't seem like a great example of "they closed the bug without ever fixing it".
I also dislike how your post is written to suggest that this was how the maintainer is closing many bugs, except you give one example which is your bug. This seems more like you are on some crusade because you don't like how your bug was handled.
I used this specific example to illustrate the general point I was making, and I took an issue I filed myself because I know for certain that it still persists. You will find other issues in the Emacs bug tracker (such as https://debbugs.gnu.org/cgi/bugreport.cgi?bug=45577) that follow the same general pattern, but where in contrast it is somewhat unclear if the issue is now solved or not, and therefore I did not cite such an issue.
Another example, an issue which I also filed and which was closed even though the issue still persists:
https://debbugs.gnu.org/cgi/bugreport.cgi?bug=35005
It is true: I do not like how these issues were handled, especially that they are closed without actually solving them. The Emacs bug tracker is also not like the one on Github, you have to control it with dedicated email messages. In fact, I would have to look up how to even "reopen" an Emacs bug, it is not very clear to users, and this makes it especially frustrating if issues are closed without solution.
My impression from several years of filing Emacs issues is that issues are currently closed prematurely more often than was previously the case. Maybe this impression is amplified by the fact that Emacs has not even had a dedicated bug tracker for a long time, so issues were never really "closed", but the discussion simply petered out.
At the top of your bug report, it says:
To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 21526 in the body.
You can then email your comments to 21526 AT debbugs.gnu.org in the normal way.Disclaimer: I did not read all 146 messages.
> "OK, let's turn things around, indeed: we revert to Stefan Bruda's indentation code, you're handed responsibility over that code, and I get to send you the bug reports about all the regressions this will introduce."
It's not clear if that's meant genuinely or frustratedly and sarcastically, but it's taken genuinely and Markus Triska replies: "This would be a good improvement in most respects I consider important, thank you! I will treat all issues you and others send to me with great care and attention, and work on correcting all regressions and issues I can. I have a lot of experience editing Prolog code with Emacs and can spot regressions quickly."
Followed by Stefan Monnier apparently not doing that, and fixing two (of many) issues raised and discussed. (Perhaps he considered it handed over and that the next action would be patches from Markus Triska?) Then 5 years later Lars (who wasn't involved in it?) closing the whole thing without reading it in detail, taking that as "whole thing fixed".
It's not too far from Zawinski's "Cascade of Attention Deficit Teenagers" model[1] of open source bug reporting - they go unread for years, then get closed with "if it's still a problem, make a new bug".
[1] https://web.archive.org/web/20210311012401/https://www.jwz.o...
That's the outcome of metrics-driven development. Getting to 0 open issues becomes the goal, and not the effect of having less buggy software.
I personally despise the GitHub "auto close" bots. Some issues take a very long time to even reproduce, and the constant nagging to close really encourages a culture of "if it can't be easily fixed, it doesn't matter" --- which nicely correlates with the state of a lot of new software today: all the basic stuff works, but there are lots of obscure, almost edge-case bugs.
This is only true if you are talking about customer-service style exchanges. With bug trackers for open source projects there can be and often is quite a bit of effort put in narrowing down the bug by the reporter or other users and sometimes the fix ends up trivial and obvious to the developer after that. I agree with closing stale bugs that have had no interaction or quick way for the dev to check if the problem is fixed (after years, not weeks) - they can be reopened after all - but dismissing the effort by done by users to report bugs in the first place should not be your justification.
If you are looking to reduce number of issues, you are on the right track, because now not only you have closed a bunch of them without putting much work into it, but less people will be bothered to document and report their issues.
So you triage your bugs into roughly the same size chunks. You measure how many of the issues you deal with per month. You prioritize the issues. If you have more issues than your monthly velocity, you close the lowest priority WONTFIX because, well, they will not be fixed. But nobody does it this way for public projects, because then they have to deal with entitled people who want their priorities to supersede your priorities, and instead you end up with an eternally growing list of bug reports that are harder and harder to maintain. And try other approaches to make it maintainable, such as making it harder to report bugs.
Bugs won't fix themselves due to not talking about them. If you want to close a report, have a human check if the reported misbehavior does still happen, and close the bug if not (or if no way to reproduce was found). Projects seem to forget that issue reports are reports on defects of their code, so they should be the first interested in fixing whatever is wrong.
I'm the kind of user who takes the time and effort to report bugs (and I'd say that already puts me on a small % of users). But when I see these "closed because of no activity", I just say "F.U., really" and go away.
https://emacsconf.org/2020/talks/38/
There's a new portable undump in emacs 27
https://www.masteringemacs.org/article/whats-new-in-emacs-27...
a couple of examples of very core features off the top of my head
Fantastic! Two birds with one stone!
If only there was a way to find out, instead of guessing.
I’m going to start trying this at work. I wonder how it will be received?
You’ve never done that at work? In every company I’ve worked for, nobody would bat an eyelid at dropping an issue that hasn’t been touched for more than a year
Developers absolutely should be testing for the issues they know about. QA is there to look for unknown issues.
Any company that depends on QA for testing and doesn’t make devs to it is miserable to work for (both as a dev and a QA).
Dont just push code and expect others to point out your flaws. Take some responsibility.
Were all problems fixed? Almost certainly not. Many will have become overcome by events, though. The ones that are still pertinent will reopen.
Such that anytime I see a large percentage of bugs closed like this, this reflects more on working in the ticketing system than it does on fixing the problem it is managing.
They report something. You badger them for six weeks to collect enough information to reproduce it. You fix the problem and slate it into a release and make it available. They don't take the release for another seven months.
https://debbugs.gnu.org/cgi/bugreport.cgi?bug=21526
In general, I find too much emphasis is now on "closing" an issue as soon as possible. I understand that open issues can be a burden for maintainers. However, filing issues, especially making them reproducible, can also be a burden to users, and users will stop filing issues if too many of them are closed unilaterally without actually correcting the root cause.
As I remember it, the Emacs maintainers used to put a lot more emphasis on actually correcting issues instead of only closing them, and this may also be the reason why fewer issues are reported now.
A great attraction of Emacs is how easily one can actually report issues, using Emacs itself: M-x report-emacs-bug RET.