This choice is called triage, a term from emergency departments in hospitals where they have to decide who gets treated (and sometimes, unfortunately, who lives and dies).
As with all business decisions, it's a cost/benefit problem. What is the benefit of fixing a bug or adding a feature? What will it cost (including the opportunity cost of not doing something else)?
Pick those that have the most benefit for least cost. What you're aiming for is the maximum bang-per-buck. Resources are limited, desires are not, the perennial problem of capitalism :-)
There's no point fixing a bug experienced by only one customer who's never going to throw more repeat business your way if it means a feature that will sell hundreds of copies is dropped in the meantime.
For what it's worth, our company has a database of requested changes where customers can basically vote for what they want to see in upcoming versions of our products. The actual creation of these requested changes in that database is limited to the sales force since we don't want all sorts of requests showing up without being evaluated and discussed at least a little bit with the customers.
In addition, we regularly approach our biggest customers (in terms of revenue generated) with the list to figure out what features should be added (they are free to suggest their own desires as well, which also get entered into the database - obviously voting power depends a bit on revenue).
This is quite separate from our bug system although quite often bugs are raised which are actually new feature requests, and they're shipped across to the new features database. It's possible that this may even happen for real bugs that are considered low-impact or have a suitable workarounds in place.
We ask our users. We have a niche product, and a small user base.
Seriously, the users group are paying maintenance, or thinking about buying.
So we ask them what they would like.
They suggest fixes, ask for new features.
We tell them about the development roadmap: because we have things we want to do to the product , due to times changing, design ideas. Changes to regulations.
And if every customer says "we really need feature X" : then it'll come next.
If they say "you guys need to fix the bug where I click there an it doesn't do blah:" then that bug gets fixed.
Commercial software: with the customers voting for changes. Of course, we take their choices on advisement: the company have other things that are thinking about.
We always look at the cost of fixing the bug versus the problems caused by it. Sometimes, it just isn't worth it to have every single bug properly triaged, root caused, then fixed.
Plenty of times a particular enhancement or new feature is being funded or at least strongly recommended to occur by a large/good customer, so that also affects matters.
I like to think that bug fixes should always come before enhancements and new features, in all cases. Even if the particular bug isn't bothering you too much as the developer, someone somewhere is having their day ruined when your little error pops up.
You have to look at it from the standpoint of what the bug is. A show-stopper bug is always number one priority. If people can't log in or critical data can't be entered or adjusted, etc. then that must take precedence over pretty much everything.
Bugs of lower significance can be worked in as need be. We may delay fixing a bug becasue we know we are working on that section for an enhancement next week. Then the bug fix will go with the enhancement. We may delay fixing a bug if it is minor and a planned enhancement will replace the code entirely shortly. A major enhancement might take precendence over fixing some typos on the interface. A client may tell us that this other project is more critical and to do it before fixing the bug (our software is highly customized by client). It all depends on the affect of the bug and existing plans and corporate politics once you are past the show stopper. A bug that is bothering a major client may take higher precedence even if it seems minor to the developer. If the CEO wants it fixed now, doesn't matter how unimportant it seems compared to the rest of the workload, it gets fixed now.
Point 5 of The Joel Test: 12 Steps to Better Code makes a compelling argument (in my opinion) that it's a good idea to fix bugs before writing new code.
For bugs, it's pretty simple: If you're going to fix it, fix it before you write any more code. Why? The more code you add, the harder the existing bug will become to find.
If you're okay with the idea of the bug never being fixed, by all means triage it over and add features.
Bugs? We have no bugs. They're undocumented features.
For us the choice is always based on business decisions and as a developer I have no input beyond offering my opinion on what should be top priority. More often than not, features win over bugs because adding features "appears" to the business area like progress is being made and bugs that I could have fixed a year ago continue to exist because the business side only wants to see "progress". Triage is great if your allowed, but all too often in the corporate environment, it's about visible results, not functionality.
One thing did not mention so far the severity of the bug. If the bug has high severity (like crash , can not pass duration test, and it surely depends on what kind of application you have) ,you should definitly fix it first before adding new feature.
发布评论
评论（10）
这种选择称为分诊，这是医院急诊科的一个术语，他们必须决定谁接受治疗（不幸的是，有时还决定谁生谁死）。
与所有业务决策一样，这是一个成本/收益问题。修复错误或添加功能有什么好处？其成本是多少（包括不做其他事情的机会成本）？
选择那些以最少的成本获得最大利益的项目。您的目标是最大性价比。资源是有限的，欲望却不是，这是资本主义的长期问题:-)
修复只有一个客户遇到的错误是没有意义的，如果这意味着一个可以销售数百份的功能被放弃，那么他永远不会给你带来更多的回头客。同时。
就其价值而言，我们公司拥有一个包含请求更改的数据库，客户基本上可以在其中投票选出他们希望在我们即将推出的产品版本中看到的内容。在该数据库中实际创建这些请求的更改仅限于销售人员，因为我们不希望在没有与客户进行评估和讨论的情况下出现各种请求。
此外，我们定期与我们最大的客户（就产生的收入而言）联系，并提供列表，以确定应添加哪些功能（他们也可以自由提出自己的愿望，这些愿望也会输入数据库 - 显然是投票权有点取决于收入）。
这与我们的错误系统完全分开，尽管经常会提出错误，这些错误实际上是新功能请求，并且它们被传送到新功能数据库。对于被认为影响较小或具有合适解决方法的真正错误，这种情况甚至可能发生。
This choice is called triage, a term from emergency departments in hospitals where they have to decide who gets treated (and sometimes, unfortunately, who lives and dies).
As with all business decisions, it's a cost/benefit problem. What is the benefit of fixing a bug or adding a feature? What will it cost (including the opportunity cost of not doing something else)?
Pick those that have the most benefit for least cost. What you're aiming for is the maximum bang-per-buck. Resources are limited, desires are not, the perennial problem of capitalism :-)
There's no point fixing a bug experienced by only one customer who's never going to throw more repeat business your way if it means a feature that will sell hundreds of copies is dropped in the meantime.
For what it's worth, our company has a database of requested changes where customers can basically vote for what they want to see in upcoming versions of our products. The actual creation of these requested changes in that database is limited to the sales force since we don't want all sorts of requests showing up without being evaluated and discussed at least a little bit with the customers.
In addition, we regularly approach our biggest customers (in terms of revenue generated) with the list to figure out what features should be added (they are free to suggest their own desires as well, which also get entered into the database - obviously voting power depends a bit on revenue).
This is quite separate from our bug system although quite often bugs are raised which are actually new feature requests, and they're shipped across to the new features database. It's possible that this may even happen for real bugs that are considered low-impact or have a suitable workarounds in place.
我们询问我们的用户。
我们有一个利基产品和一个小的用户群。
说实话，用户群体正在支付维护费用，或者正在考虑购买。
所以我们问他们想要什么。
他们建议修复，要求新功能。
我们告诉他们开发路线图：因为我们有我们想要对产品做的事情，
由于时代的变迁，设计理念的变化。法规变更。
如果每个客户都说“我们真的需要 X 功能”：那么接下来就会出现。
如果他们说“你们需要修复我点击那里的错误，但它不起作用：”那么该错误就会得到修复。
商业软件：由客户投票决定变更。
当然，我们会根据他们的建议做出选择：公司还有其他正在考虑的事情。
We ask our users.
We have a niche product, and a small user base.
Seriously, the users group are paying maintenance, or thinking about buying.
So we ask them what they would like.
They suggest fixes, ask for new features.
We tell them about the development roadmap: because we have things we want to do to the product ,
due to times changing, design ideas. Changes to regulations.
And if every customer says "we really need feature X" : then it'll come next.
If they say "you guys need to fix the bug where I click there an it doesn't do blah:" then that bug gets fixed.
Commercial software: with the customers voting for changes.
Of course, we take their choices on advisement: the company have other things that are thinking about.
我们总是关注修复错误的成本与它引起的问题。有时，对每个错误进行正确分类、找出根源然后修复是不值得的。
很多时候，某个特定的增强功能或新功能正在由大/好客户资助或至少强烈建议进行，因此这也会影响事情。
We always look at the cost of fixing the bug versus the problems caused by it. Sometimes, it just isn't worth it to have every single bug properly triaged, root caused, then fixed.
Plenty of times a particular enhancement or new feature is being funded or at least strongly recommended to occur by a large/good customer, so that also affects matters.
我认为在任何情况下，错误修复都应始终先于增强功能和新功能。即使特定的错误并没有对开发人员造成太多困扰，但当你的小错误弹出时，某个地方的某个人的一天就会被毁掉。
I like to think that bug fixes should always come before enhancements and new features, in all cases. Even if the particular bug isn't bothering you too much as the developer, someone somewhere is having their day ruined when your little error pops up.
区分，是的。
错误优先，是的。
首先是所有关键/正常优先级及以上的错误，是的。
是的，80/20 规则。
不，错误和功能必须区别对待，因为它们的权重不同。
是的，所有商业、开源和内部应用程序都有自己的做事方式。
例如，FogBugz 使用基于证据的调度，并且是我所知道的唯一使用该公式的管理/跟踪器。
希望有帮助！
distinguish, yes.
bugs take priority, yes.
all critical / normal priority and above bugs first, yes.
yes, the 80/20 rule.
no, bugs and features have to be treated differently because they are weighted differently.
yes, all commercial, open-source, and in house applications have their own way to do things.
As an example, FogBugz uses Evidence Based Scheduling and is the only management/tracker that i know of that uses that formula.
Hope that helps!
你必须从错误是什么的角度来看待它。令人惊叹的错误始终是第一要务。如果人们无法登录或无法输入或调整关键数据等，那么这必须优先于几乎所有事情。
重要性较低的错误可以根据需要进行修复。我们可能会推迟修复错误，因为我们知道下周我们将在该部分进行增强。然后错误修复将与增强一起进行。如果错误很小，我们可能会延迟修复，并且计划的增强功能将很快完全替换代码。重大增强可能优先于修复界面上的一些拼写错误。客户可能会告诉我们，另一个项目更重要，需要在修复错误之前完成（我们的软件是由客户高度定制的）。一旦你超越了阻碍，这一切都取决于错误的影响以及现有计划和公司政治。困扰主要客户的错误可能会具有更高的优先级，即使它对开发人员来说似乎很小。如果首席执行官希望现在修复它，那么无论与其他工作负载相比它看起来多么不重要，它现在都会得到修复。
You have to look at it from the standpoint of what the bug is. A show-stopper bug is always number one priority. If people can't log in or critical data can't be entered or adjusted, etc. then that must take precedence over pretty much everything.
Bugs of lower significance can be worked in as need be. We may delay fixing a bug becasue we know we are working on that section for an enhancement next week. Then the bug fix will go with the enhancement. We may delay fixing a bug if it is minor and a planned enhancement will replace the code entirely shortly. A major enhancement might take precendence over fixing some typos on the interface. A client may tell us that this other project is more critical and to do it before fixing the bug (our software is highly customized by client). It all depends on the affect of the bug and existing plans and corporate politics once you are past the show stopper. A bug that is bothering a major client may take higher precedence even if it seems minor to the developer. If the CEO wants it fixed now, doesn't matter how unimportant it seems compared to the rest of the workload, it gets fixed now.
Joel 测试：改进代码的 12 个步骤 的第 5 点提出了令人信服的论点（< em>在我看来）在编写新代码之前修复错误是个好主意。
Point 5 of The Joel Test: 12 Steps to Better Code makes a compelling argument (in my opinion) that it's a good idea to fix bugs before writing new code.
对于错误，这非常简单：如果您要修复它，请在编写更多代码之前修复它。为什么？添加的代码越多，现有的错误就越难发现。
如果您认为错误永远不会被修复，那么请务必对其进行分类并添加功能。
For bugs, it's pretty simple: If you're going to fix it, fix it before you write any more code. Why? The more code you add, the harder the existing bug will become to find.
If you're okay with the idea of the bug never being fixed, by all means triage it over and add features.
虫子？我们没有错误。它们是未记录的功能。
对于我们来说，选择始终基于业务决策，作为开发人员，我除了就什么应该是最优先的事项提出我的意见外没有任何意见。通常情况下，功能会战胜错误，因为添加功能“看起来”到业务领域正在取得进展，而我一年前就可以修复的错误仍然存在，因为业务方只想看到“进展”。如果您允许的话，分类是很好的，但在企业环境中，它通常是关于可见的结果，而不是功能。
Bugs? We have no bugs. They're undocumented features.
For us the choice is always based on business decisions and as a developer I have no input beyond offering my opinion on what should be top priority. More often than not, features win over bugs because adding features "appears" to the business area like progress is being made and bugs that I could have fixed a year ago continue to exist because the business side only wants to see "progress". Triage is great if your allowed, but all too often in the corporate environment, it's about visible results, not functionality.
到目前为止，有一件事没有提到该错误的严重性。如果错误的严重性很高（例如崩溃，无法通过持续时间测试，这肯定取决于您拥有什么样的应用程序），那么您绝对应该在添加新功能之前先修复它。
One thing did not mention so far the severity of the bug. If the bug has high severity (like crash , can not pass duration test, and it surely depends on what kind of application you have) ,you should definitly fix it first before adding new feature.