[nowayjose2]

I have a funny feeling that the nontechnical people on my current project would be nodding their heads along to the article, but the truth is that our applications have bugs that 100% of our customers are running into; they simply aren't immediately noticeable to a layperson. That doesn't mean they're not important. The business relies on complying with the rules of third-party organizations and the software is blatantly violating those rules right now. The clients are aware but still choose to prioritize new features over fixing the bugs that are creating these compliance issues. If we're caught out by those third parties before the bugs are fixed, there's a good chance it could sink the whole company. But our users don't "see" these bugs so they're not considered a priority over new products, new features, or anything else marketing might want.

I looked up Pinedo's background and she's not a developer; she's a social media manager. This is kind of what I figured because her perspective on development seemed really out of whack to me. There are many kinds of bugs that can't be measured with a simple stability calculation, and IME there are definitely error states that are worse than death (crashes). Plus 97% of teams are definitely not following agile principles. Every dev team I've ever been on said it was agile, and most of them just meant that there was a kanban board and something that vaguely approximated a sprint.

[ryandrake]

One of the toughest things I struggled with while transitioning from a larval junior developer to a senior tech lead to a project manager was the fact that (at least in the context of a for-profit business) not all bugs need to be fixed, even the ones you personally think are really really bad. The goal is to make money, not necessarily by producing the most perfect software. The quality bar needs to be high, but there is always a point beyond which the returns for fixing a bug are outweighed by the costs of fixing it: the direct engineering cost, the opportunity cost of not working on a feature, the cost of missing a deadline and not releasing in time for Christmas, the cost associated with the extra risk you’re taking by making a late change, etc. Good places judge all these costs, and the best ones have formal processes for judging lots of bugs at scale and constantly re-evaluate whether a bug should be fixed at this point in the project or not. Sometimes the clear right answer is “no.”

[wilun]

That's fair, but one has to remember that some of the key points are to be balanced, and that, like you said, "the quality bar needs to be high".

And I'm more for prioritizing trying to not introduce bugs than to fix all the old ones. Which is challenging on, how could we call that?, "legacy" software. So that priority can and must be reversed temporarily when that "legacy" is too much.

So it's all very context dependent, and not having anybody (or too few) working on making things better when its needed is not going to deliver any kind of velocity in the long term (and probably the short term velocity is already way too low in those cases). Too bad for the mythical time to market...

So you have to be able to say no to bugfixes, but you certainly also have to be able to say no to the eternal rush of new half-backed features, when needed. A short-term ever obsession on "opportunity cost of not working on a feature" could yield quite paradoxical results if trying to build them on some kind of zombie legacy code (that is only ever edited with disgust and great difficulty, but never seriously refactored).

Not only this balance is hard to achieve, but your role as a senior tech lead and project manager is certainly to consider carefully the cleanup needs, and be an advocate for them when needed, including by pushing back against feature creep pressure. Because if you are not, most of the time nobody else will. As a tech lead, this mean among other things, that a black box approach of parts of the maintained software is out of the question (of course you can delegate, but even then its imperative to stay in the equation for that purpose, only with less details). Paradoxically, even if the quality is crap and the organization notices and tracks loads of bugs, most people will be happy at the moment the bugs are triaged and assigned and eventually "fixed" by more horrible garbage (that is, the impression that something is done), rather than doing the right thing that is to organize a cleanup of the software more in depth.

I've got the impression that it is rare to find projects where this balance is achieved correctly, but maybe it's only because of bad luck. Well in lots of cases, the famous ones (I'm thinking on the level of Linux, Firefox, Python, etc. not just your random niche software) are actually not that bad, and their competitors have a way shorter lifespan when not as balanced...

[dgreensp]

This is my experience as well. Product progress is prioritized over code quality, and the ultimate cost to velocity is real but often unacknowledged. Bugs go unfixed because they are very hard to fix, and this high cost is taken for granted.

It’s definitely on the technical leadership to stand up for code cleanliness and push back against product, and on the higher-ups to recognize the importance of this dynamic.

[quanticle]

    One of the toughest things I struggled with while transitioning from a 
    larval junior developer to a senior tech lead to a project manager was the 
    fact that (at least in the context of a for-profit business) not all bugs 
    need to be fixed, even the ones you personally think are really really 
    bad. The goal is to make money, not necessarily by producing the most 
    perfect software.

On the other hand, you have to remember the that impact = risk x loss. And developers and managers are notoriously bad at evaluating the risk posed by a bug. It does no good for software to make $10 millon dollars a year for 5 years and then make a $100 millon dollar loss in the sixth, because of a catastrophic bug that no one prioritized fixing because, "It's been 5 years and no one's run into this bug yet."

[dexterous]

> developers and managers are notoriously bad at

So, basically, everybody is bad at it.

[rajangdavis]

Totally understand that a project can't be perfect, and I could be wrong, but I feel that if there are a lot of bugs, the project scope is too big and/or the requirements are not well understood.

There is also the matter of really picky customers; however, if a customer can articulate what you are doing wrong, I don't think that it's a bad thing if they are picky.

Quality should be in step with expectations; selling services that can't be achieved with in a specific time slot is worse than trying to fix all of the bugs.

[btschaegg]

> [...] I feel that if there are a lot of bugs, the project scope is too big and/or the requirements are not well understood.

Indeed. And I'm under the impression that the project's take on fixing issues (not just bugs!) is a central part of that, which goes against OP's argument somewhat:

Scope/requirements are usually not out of whack because nobody thought about it when the project started (that's a whole other world of bad project management). The fact is that we're not good at all at judging how the scope and the requirements will change in the future. When (not if!) that eventually happens, you cannot just go adding random changes and edge cases forever, or you'll end up with a horrible Rube Goldberg machine no one has ever even a chance of understanding. You'll have to consistently monitor the sanity and accuracy of your model and either choose to limit the scope of the thing you're building or to correct the model for those edge cases you haven't considered, lest you monkeypatch yourself into a corner.

Now, those bugs that cost so much to fix are usually those where your model breaks down. And that, in turn, is where it's necessary to regurarly step back, find out which part of the model doesn't fit reality anymore and how you can fix it. Then, you can make one of the two decisions above. I've seen my fair share of code in projects where that wasn't done properly, and sometimes, only ignorance on the management side can explain the lack of panic regarding that code.

> Quality should be in step with expectations; selling services that can't be achieved with in a specific time slot is worse than trying to fix all of the bugs.

Well said.

[Phrodo_00]

I agree, but I think you still need to be deliberate about not fixing bugs. Sure, don't fix it, but create a ticket for it and use it to track how common it actually is.

You also should probably be fixing bugs that "If we're caught out by those third parties before the bugs are fixed, there's a good chance it could sink the whole company"

[loopj]

Heads up - I co-wrote this article with Kristine and this is based around the whole thesis of our company existing - I'm a software developer by trade with 15 years of experience. Having said that, dismissing the content based on the author I think comes across as an ad-hominem attack - after working with her for 4 years I count Kristine as an expert on this matter.

The overall point here isn't to use this as an excuse to not fix bugs, more that you should consider applying the same logic as devops/sre teams use for "uptime and availability" (5 nines, etc) to software stability to help you move faster as a company.

[natalyarostova]

It's not an ad-hominem. It's an inference on the predictive power of the article as a function of the commenters prior belief on the expertise of non-developers.

They may or may not be right, but you can't just dismiss things you don't like by classifying them as a "fallacy."

[User23]

The opening Dijkstra quote is out of context and deeply misleading. See https://www.cs.utexas.edu/~EWD/transcriptions/EWD03xx/EWD303... for his views on the subject.

[nowayjose2]

I just want to note -- I didn't dismiss the article based on the author's background; I was baffled after reading the article because it made no sense to me when I was reading it from the perspective of someone I initially assumed was a developer. I'm not really sure how someone can develop expertise in software development without having participated in the process, but if you cowrote the article maybe you can explain? Do you agree 97% of developers are following agile principles and that this stability formula is a good way to measure the overall bugginess of an application?

[Retric]

Agile is not about the details. If you are producing shippable versions of your product every 2 months or less then your probably Agile relative to what existed when the term was invented.

[nowayjose2]

Maybe if you mean little-a agile, as in the dictionary definition "moving quickly". Big-A Agile, as in the set of software development principles, has a bit more to it than that.

http://agilemanifesto.org/principles.html

[Retric]

Nothing on that list is a specific requirement for a specific methodology. “The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.”

That does not say you can’t have a distributed team. It simply says face to face communication is best.

[coldtea]

>I have a funny feeling that the nontechnical people on my current project would be nodding their heads along to the article, but the truth is that our applications have bugs that 100% of our customers are running into; they simply aren't immediately noticeable to a layperson. That doesn't mean they're not important.

If they're not noticeable, and the customers keep buying, despite 100% of them having them, how are they "important"?

>The business relies on complying with the rules of third-party organizations and the software is blatantly violating those rules right now.

That's a business decision. It could even be illegal (but still not big of a deal depending on circumstances) but not a bug.

[nowayjose2]

The bugs will be very noticeable to stakeholders who are not end users, if they decide to look. The users don't buy the software because they want to; they buy it because they are required to. If groups we're supposed to be accountable to see the shenanigans we're up to and say, sorry no dice, you have to try again with some other company that made their software properly, _then_ the users will be upset because they'll be out mucho dinero for nothing. The end users don't know what rules we're supposed to be following on our end, nor should they have to.

Where I come from, if software doesn't meet requirements and instead produces incorrect results, it's considered a bug. To use another example from a different company I've worked for, I once found out that the financial reports generated by a particular piece of software were all completely wrong due to errors in the way calculations were done. I pointed this out to the higher-ups and they agreed that there was a bug and that all the existing financial reports were in significant error. They refused to let me fix it, not because we didn't have time (there was plenty, and I was otherwise free to work on pretty much whatever was in the backlog), but because fixing the bug would let the customers know that there was a bug in the first place. Some of this data would end up getting passed on to shareholders and the government. Is this not a bug? In the current case, the reason we're not complying with the rules was because of a bad architectural decision that wasn't properly cleared with anyone before it was implemented.

I guess I'm just not on board with the "just following orders" school of software development when the negligence involved rises to the level of illegality and scams. I'm happy to write a lot of software that I personally think is wonky or strange, but for me it stops when we start ripping people off and breaking the law.

[coldtea]

>They refused to let me fix it, not because we didn't have time (there was plenty, and I was otherwise free to work on pretty much whatever was in the backlog), but because fixing the bug would let the customers know that there was a bug in the first place. Some of this data would end up getting passed on to shareholders and the government. Is this not a bug?

No, it's an opportunity to ask for a large sum of money, to leave the company and not talk about it.

[_r_o_y_]

It's not exactly related to your post but remember that Agile != Sprints

[nowayjose2]

I know, but that doesn't stop managers from claiming that any process on some kind of n-week cycle is "agile". Maybe I've had bad luck, but it feels like a lot of companies pick up some agile-for-managers book and implement whichever process is there, minus the parts of the process that make them uncomfortable, and the results are often not great.

[qznc]

That is like Open Source != FOSS, a lost cause.

[matthewmacleod]

No, it’s not. That kind of atfitude is pervasive and wrong.

Loads of teams are nowhere near Scrum and work basically Kanban. That’s reasonably agile.