3 ms·
> We know from observing reality that even buggy software is better than no software – a software so buggy it adds negative value is a rare exception. So I gues
by AnimalMuppet 4y ago
> We know from observing reality that even buggy software is better than no software – a software so buggy it adds negative value is a rare exception. So I guess it has to be "sub-linear", otherwise software wouldn't have economies of scale.
Your logic is flawed here. First, software has economies of scale because it's easy to produce the second copy of a program once you have the first one. It has nothing to do with lines of code.
Second, buggy software being better than no software would still be true even if bugs were super-linear in the number of lines of code.
I'm pretty sure that bugs aren't sub-linear. As you pile on more and more lines of code, the number of bugs per thousand lines goes down? The code gets better as you create more and more of it? Experientially, no.
I think it's super-linear, for a couple of reasons. First, the bigger the program, the bigger the team. The bigger the team, the more below-average coders on it. Second, the bigger the program, the more room for weird interactions between obscure conditions.
No, it's definitely not sub-linear. Bugs per line of code do not decrease as you have more lines. I suspect it's
- rrwo 4y agoA bigger team doesn't create buggy software because it contains below average coders. It creates buggy software because the team members have to coordinate with more people.
- TeMPOraL 4y ago> A bigger team doesn't create buggy software because it contains below average coders. But it must, by the very meaning of "below average coders" - it's implied that we're rating hypothetical coders on software development skills, which include the ability to make correct decisions (both at code and architecture level). > It creates buggy software because the team members have to coordinate with more people. Those are not independent variables. The bigger the team, the bigger coordination problems, the more bugs. But also, ceteris paribus, the worse the coder, the more problems there are coordinating with them, thus the more bugs. And also, ceteris paribus, the worse coders are on average in the team relative to global average, the more of them are needed for a project, which makes the team bigger and coordination more difficult. Etc.