Qt’s Open Bug Tracker

Qt has had an open bug-tracker for a few months now. I am very happy about that. It has made life far more pleasant for Qt developers compared to the past. However, there are some problems. In summary, bug reporters are often treated like the enemy instead of contributors, and this could be fixed easily.

My company, Openismus, provides bugmasters to corporate open source projects such as maemo.org. We know how to make the best use of outside contributions, so enthusiasts stay loyal, and we know how to manage bug databases for the long term. See the overwhelmingly positive feedback for Andre and Karsten, maemo.org’s bugmasters. They acquired these skills while establishing  GNOME’s bug squad, working on GNOME’s huge bug database.

I have linked to some Qt bugs as anecdotal examples of poor interaction with bug reporters. I am not interested in a discussion here of the technical aspects of these bugs. They are not meant to be technically critical. Also, half of them are for QtMobility, whose developers are generally very helpful, but even they haven’t learned the best bug-tracker habits. I don’t think I have seen enough Qt bug reports to have a fully representative sample, but my short experience does suggest that there are serious problems. I don’t mean to exaggerate or be unfair.

Awkward UI

Let’s look at a random bug. This view (not this particular bug) will be the first look at the bug-tracker for many people, as they follow a link to an existing bug. But it does not seem designed for humans. There are some particular problems:

How do I add a comment?

Typically, I’ll read the comments on a bug report to see what’s happening. But then there’s no obvious way to add my own comment. If I look around then I finally see a “Comment on this issue” link nestled among other less important action at the left hand side. I believe that many people won’t find that link, or will be discouraged by the awkwardness. I much prefer just writing a comment right into a bugzilla page.


The “all” page is too complicated, with lots of machine-generated noise. Instead of fixing that, there are tabs that show reduced views: All, Comments, Work Log, Change History, Transitions. This makes the whole page seem even more complicated.

The all page is so nasty that many people will switch to the comments page. But then comments lose their context. For instance, here (bug 7303) the Qt employee seems to be blaming the reporter though he is really just talking to someone that he has assigned the bug to. I’d rather just see a single page, as in bugzilla, without so much noise. The notification emails are similarly padded with irrelevant details.

Rush to close

We notice a strong tendency for the Qt employees to close bugs at any cost for any arbitrary reason as quickly as possible. Presumably they are under pressure to reduce the simple number of open bugs. But a bug-tracker exists to collect information that can gradually be used to improve software. If you think of everything as short-term and rush to ignore that information then you will not make the improvements and customers will assume that you don’t care.

Hard to check the fix

When I close bugs, I mention at least the commit message that I used. Sometimes I link to the commit’s web page on our gitweb or gitorious. But Qt bugs are often closed with a mention of the git commit ID (such as d65d3becc292523f0962aac9d2bf7b96d9c47c04), with no link. For instance, bug 8865 and bug 5729. I am thankful for the fixes but, particularly for documentation fixes, it’s best if I can verify it and reply quickly.

Viewing the change for a particular commit ID is awkward, requiring lengthy use of the command line outside of the browser. Even the gitorious web site doesn’t let me search for a commit ID, so I have to browse through pages of recent commits using the browsers find-on-page feature.

Actually, the person fixing the bug often cannot provide a gitorious web link at that time because that commit isn’t even public yet, because Qt’s gitorious repository is just a mirror, updated approximately daily from a secret repository. Things would be easier if they just worked in an open repository. In the meantime, Qt’s bug tracker should be hacked to recognize and link commit IDs, showing a “try tomorrow” page if the commit is not yet public.

Not supported. Not public

If the Qt developers decide (after the fact) that something in Qt is not supported then the bug may be closed, instead of leaving it open for someone to fix. But if something is not supported then it shouldn’t be in the release. For instance, bug 7334.

There’s also lots of Qt API that is used widely but not documented. Bug reports about the lack of documentation may be closed instead of leaving it open for someone to fix. But all API should be documented for the sake of implementation quality, regardless of whether it is public. And if API shouldn’t be used then its documentation should say that it shouldn’t be used.

Closing bugs because they require work

Bugs are sometimes closed because they would require effort to fix them. This makes no sense to me. Even if no Qt employee plans to fix them, they should stay open so others can fix them, and so that the information is kept in one bug report, with repeated reports being marked as duplicates. For instance, bug 5915.

Sometimes the idea of necessary work seems to be invented just as a way to close a bug. For instance, in bug 5729, a simple patch is not enough. The reporter is told that he must test it on multiple platforms, ignoring the possibility to test the harmless change widely during regular unstable releases.

For non-employees, the page even has some probably-unintentional machine-generated “You don’t have permission to work on this issue” at the left, just in case the reader didn’t feel unwanted enough already.

Out Of Scope

Likewise, if the Qt developers don’t personally see a problem as their priority then they will sometimes close it as “Out Of Scope”, regardless of whether the reporter cares about it or whether he might provide a patch.

Sometimes (bug 5729 again) this happens without the Qt employee even writing a comment explaining why. This is the bug-tracker equivalent of “Go away. We don’t want you to use our software”. Stopping this should be a top priority.

I’ve also seen one case (bug 6074) where this was used when the Qt developer meant “already fixed”. Until I asked for clarification (most people don’t) I assumed that they just didn’t care.

Can’t reopen bugs.

If a fix is not good enough, or the Qt employee has misunderstood the problem, I can’t reopen the bug. That is very frustrating. Most people will not beg for the bug to be reopened or even bother continuing to comment on the closed bug. Luckily we do have the option to submit gitorious merge requests when our bug has been incorrectly closed. For instance, bug 11496.

Can’t close bugs

There’s also no way for external contributors to close bugs. So Qt gets no outside help with bug triaging. This arbitrary separation between employees and external contributors is an obstacle to open development.

6 thoughts on “Qt’s Open Bug Tracker

  1. The delay before Qt repositories become available was recently shortened to 1h (instead of 12h as it was before). Much better!

  2. Wow, didn’t know about this lack of openness.

    Most problems you reported may be fixed by just actually fixing JIRA (or making them migrate to Bugzilla, which is much better).

  3. A few of the problems you describe happen in Maemo’s bug tracker too. It uses bugzilla, so it has less UI awkwardness; furthermore, non-Nokia employees can get access to manipulate bugs. However, I’ve seen (and experienced) many examples of “rush to close”, “out of scope”, and “closing bugs because they require work”. “Hard to check the fix” also applies, since fixes often don’t say exactly what changed, in what package/version, or anything other than “will show up in the next firmware”. And it doesn’t help that the maemo.org bugzilla is not the *real* bugtracker; that one lives inside Nokia, and bugs only have a hope of getting fixed if someone cares enough to open an internal bug; once that bug *does* get opened, someone has to manually report the results of it to the external bug, or conversely pass on additional information to the internal bug.

    1. @Anonymous: In many cases this has to do with Nokia’s partially paranoid policies that ignore open-source culture and expectations and that I only “forward” Nokia’s decisions to bugs.maemo.org. Much stuff is also WONTFIX for Maemo5 because MeeGo will change a lot of things (and code).
      “Hard to check the fix” applies though I always try to post a direct link to the commit in gitorious if I am aware of it and if the code for the specific module is open (at least for Modest I’m totally sure that I’ve always posted direct git commit links in the recent past). In cases I don’t do though the code is open please feel encouraged to ask me in bugs.maemo.org for the concrete commit.
      I don’t share the “in what package/version” criticism as I always post the exact package and version name if I (and Nokia) am aware of it and a concrete code fix has taken place (this of course does not work for issues that could not be reproduced and hence were considered “already fixed in the past”).

      The criticism on the construction to have an external bugtracker that is only one input channel for Nokia for their internal bugtracker is of course valid and I’m happy to see that for MeeGo core this will not work out for Nokia anymore as they have to work in the open. However I don’t know Nokia’s concept (they probably don’t have one yet) for future releases based on the open MeeGo core that might include additional Nokia closed-source modules on top of it. I do not want to have a “not the real bugtracker” situation again for future MeeGo based releases and I’ve told Nokia to think about a saner way how to handle that in the future as I’m unwilling to continue this game the way it currently works, however more pressure on them is of course always welcome.

      — andre (maemo.org bugmaster)

  4. This really looks like ugly JIRA.
    We do have this tool also in our company, and I can’t work with it.

    The way of doing bug work in JIRA is even more complicated then Bugzilla.

Comments are closed.