Comment by crabbone | Hacker News Reader

Comment by crabbone | Hacker News Reader

Parent Full thread

I keep looking at various JIRA alternatives, but no good finds so far. This is definitely not it.

I don't really like the idea of bug tracker as a sort of a GUI program that acts like time management software, i.e. focuses on planning work, tracking how much effort was spent, ability to add notes to tasks etc.

My ideal bug-tracking software works more like Git: it has a server-client relationship where clients query the database with predefined set of commands, while at the same time it has programmable interface facing test code. This interface should enable tests to do things like:

* figure out what components need tests to run against them when a particular feature branch sees a code update.

* extract history of tests running against a defined group of features.

* manage association of tests and program components.

* manage test sets that aren't feature-related (eg. nightlies).

JIRA kind of has this database / query component, but all the functionality above needs to be built on top of it. And the data organization of JIRA relies on issues as the basic unit, where I'd like the basic component to be "features" (similar to how branches are in Git).

My biggest problem with the currently popular approach (emphasis on time management) is that it's very informal and unstructured when it comes to testing, poorly automated and poorly integrated with other development tools to the point that it makes it both easy to forget to do the necessary stuff and a very repetitive chore to keep the necessary stuff up-to-date, while it's clear that it's possible to automate it.

The attempts to automate this process by adding bots that manage issue life-cycle or generate trivial fixes / merge trivial PRs isn't the way to solve the problem, IMO because this automation is stupid and has a potential to cause harm. Instead it needs to be very tightly integrated with VCS (but, let's be honest, with Git) to the point that such configuration would require minimal effort on the part of the admin and be vendor-independent, and, most importantly, be feature-oriented to mirror how programmers conceptualize the development of their program.

I really appreciate your feedback here and I see where you're coming from and can agree if you're looking at Jira as a purely bug tracking / development tool.

Unfortunately, and I think important to call out -- is that most companies are trying to use these tools as a "catch all" -- "a one in all solution that solves everyone's problems" and then ultimately, half of the company refuses to use the tools because it's too focused on one user group.

Our long term approach is really about making work and getting sh*t done as a relevant part of the PM process and less on time management. Time management is part of organization but people want to care about what they're building and why... something that can be absent in a lot of orgs and even in how we organize ourselves in small teams, startups or small businesses.

What I do hear and think would be interesting -- is incorporating a plugin more specific to your workflow mentioned here... because absolutely, tighter QA, etc, is vital and there are things not otherwise easily replicated as part of a dev's flow. We, otherwise, don't have any current intentions to use "bots" in a way that automates things that people should really still be overseeing.

Yeah, what they're asking for needs to be an app / integration / plugin that ties different solutions together. A kitchen sink approach will forever be mired in gigantic codebases that a single group or company can't coherently maintain [at a reasonable time or cost], and a marketplace of solutions is better able to evolve. We need more simple and specific tools that don't do much, but can be combined with other simple specific tools.

Take branching models for example. Why do we have different "branching models" that work certain ways? Firstly because somebody built a tool that works a certain way (Git) and people need to figure out how to use it. Secondly because how you use it has a direct effect on other things, so you need some coherent model for how your group will use it. And thirdly because there's a few specific ways of using the tool, so we write those down and give it a name. Nobody set out to design these branching models, they just evolved as people started using the tool in different ways.

The same should (and kinda does) happen with project management, time tracking, issue/bug/work tracking, documentation, incident response, budgeting, etc. But mostly it's within one ecosystem (Atlassian's) or another. It should really be more general, and it should be easier to integrate different solutions and build on top, and from there new standard patterns can emerge such that we don't have to be stuck into one ecosystem.

Well, if you are going in the direction of tighter QA integration, there are several interesting things that tools like JIRA are missing, and sometimes plugins try to complement, but not quite.

If we accept that bug tracker is to be a planning program, then QA usually needs a lot more than a free-form JIRA story can offer. QA really needs what they call "test plans".

Usually, to test a feature QA, beside writing tests, needs to organize it as an activity, which might be also relevant to release management, but in general may touch on other product life-cycle phases. This comes from the fact that some rare activities performed by QA are not worth automating, and sometimes are very hard to automate (eg. uploading the program to some kind of third-party store, where it needs to be approved by the store's moderators, sometimes requiring back-and-forth with developers / QA / release management). Other typical QA tasks would include producing reports, producing or studying release notes, studying feature definitions, and perhaps, scheduling meetings with people responsible for the said features.

Sometimes QA needs to run a proper scientific research, with all that entails: research planning and execution which are often also quite regimented, but would need to be built on top of tools like JIRA which don't offer any structure to the story, and the existing superstructures of stories (eg. epics or various links between issues) don't cover because they act more like arrays or trees, where what you want is structs / documents.

On the other side, project managers need a structured and formal way to deliver product requirements to R&D, from which QA will later have to produce tests. Again, free-form issues aren't enough here because the structure will have to be written down as free-form text, but will be very repetitive, unverifiable and lead to feature planning mistakes.

If a bug tracker offered a more structured approach to feature planning by formalizing the aspects of this process, this may lead to generation of program stubs as well as test stubs (the promise UML made but never really delivered).

I can recommend Linear[0]

No affiliation. Simply, I really like how it works, and its a great interface as well. Really gets out of your way, has solid integrations and a good API for building your own

[0]: https://linear.app/

Thanks. I'll take a look.

On the surface: it's the same as JIRA, Mantis, RedMine, Track etc.: a time-tracking GUI program. Not at all what I wanted. There's nothing bad about being a time-tracker, just not what I need.

Reply on news.ycombinator.com