The bug tracker is among the least reinvented products in decades. We are changing it. But even before we reinvented it, we asked – what does a reinvented bug tracker look like?
Why reinvent something that is working?
Bug tracking tools empower development teams at every step of the bug life cycle. The tool facilitates the logging by the testers of concise and accurate bug reports. Bug reports help developers in reproducing the bugs and quickly fixing them. The hallmark of a good bug report is that it should not require any further communication or follow-up questions. The time, thus saved, helps testers uncover more bugs and gives the developers more time to fix them.
Describing a bug accurately via text is torturous. Text descriptions are inherently prone to wrong interpretations or providing only an incomplete understanding – causing delays in the fixing of bugs.
Bug tracking tools incorporate features that enable capturing the tester’s screen or the video recording, reproducing bugs to overcome this limitation. Such features intend to eliminate the possibility of incomplete or improper understanding of the bug. A screenshot of each step in a bug makes the bug report more accurate and comprehensible. The video recording feature is practical for complex bugs that require many steps to reproduce.
Undeniably, visual capabilities in the tracking tool help mitigate problems related to poor bug descriptions, speed up the bug fixing process, and shorten the product development lifecycle – but they add to the cognitive load on the developers and testers.
The cognitive load arises from the increased complexity of the tool, which, although feature-rich, is often designed by engineers with a focus on the technology powering the tool. They end up paying inadequate attention to user experience and, at worst, even totally ignoring the user perspective. Over the long term, users are fatigued by such tools, leading to errors in their work and reducing overall productivity.
What approach should the solution take?
Even as technology is evolving, does it make sense to persist with a tool that – although working – is clearly past its use-by date?
The questions that software developers, including those developing bug trackers, are grappling with include:
- When do you automate a process?
- How much to augment ‘human power’?
- How does one navigate the challenges of test automation?
- What is the best way to handle UI changes, multiple error handling, etc.?
It is crucial to understand that building modern software requires a sound build strategy, skilled talent, and modern tools to negotiate these software development challenges. For example, AI-embedded software is becoming the default across industries – from automated production and supply chain management to financial services.
Legacy tools will not suffice. Developers spend a lot of time interacting with build tools. The build-tools landscape is constantly evolving. Choosing the right tool demands a shift in focus – from viewing software development as a broad, process-intensive effort to first breaking down the end goal into smaller goals and then identifying the tools that best address each hyper-specific need.
What does a reinvented bug tracker look like?
There are bug tracking tools, and then there are more bug tracking tools. It is why there are hundreds of them out there. All of them are doing a passable job. However, their UI leaves much to complain about. Ideal bug tracking interfaces need to be more personable and understanding of the user’s needs.
The trackers, without exception, do not differentiate between the developers and the testers. A reinvented tracker will make this differentiation. Ideally, a tester’s screen will display all the bugs ready for review. It is because only the tester has the power to confirm whether a bug is fixed.
On the other hand, at this time, the developer’s screen will not have any bugs to review. Their screen will display the number of bugs under review and how many have come for rework. These are the sorts of UI capabilities in a reinvented tracker differentiated for developers and testers. Developers and testers should customize the look to make visible only those crucial to them. This differentiation in developer/tester UI is critical – to reducing the cognitive load on both of them.
In bug trackers, the bug fixing process has a definite direction. When a tester assigns a bug, the developer has to fix it. If the developer needs additional information, the tester should provide the information. After the developer has fixed the bug, the tester must confirm that the bug is fixed. There is always an action to be performed.
An ideal tracker tailors the message such that the following action is clear. They inform the developer when a tester sets a bug as Ready for Review. The developer then works on the bug. At this point, the bug is either fixed or not; the developer informs of the reason if not fixed. Automation should ensure that if an issue has not been acted upon, it should be considered a stale issue and be closed. If an issue is not assigned to anyone, then after three days, it should be auto-assigned to the product owner to act on or allocate to someone. It saves time and makes the issue move to the closure faster.
Context for Greater Understanding
All trackers maintain bug history. Typically, this history is differentiated by type – comments, status change, reassignment, etc. Instead, the history should be sorted by date. It will help establish context. A comment has a different context when it is known that it happened after a particular status change and before it was reassigned to someone. Sorting by date provides the developer/tester with highlighted information from only after their last visit to the history section – saving them the trouble of reading the entire history.
Differentiation ensures that even though the features have been enhanced, redundant UI has been eliminated. Adding features does not necessarily require an overload of UI.
Bugasura keeps these thoughts in mind to aid a visually rich yet complexity-free environment for engineers, product, and testing teams to collaborate and work with ease.
We all hate visual complexity. Software that causes less fatigue will ease and enhance a person’s life. While we might be reinventing a bug tracker, our customers might end up smiling more in their life due to reduced stress. We might never hear from our users, but we know that that is how we are impacting people’s lives beyond work.