Is the number of bugs falling as new Ubuntu releases are released? [closed]

If we could count the number of bugs per Ubuntu release (... 10.04, 10.10, 11.04, ...), would it be a decreasing line?

If not, why not? Is not the whole point of new releases to fix previous issues? Can we not dream of a flawless Ubuntu LTS?

Solution 1:

No. New releases will have new software and new versions of a software so those will have totally new bugs.

New hardware also introduces new drivers, new software and thus new bugs.

Is not the whole point of new releases to fix previous issues?

You can also fix bugs by removing software and switching to some other software that has a lesser footprint (less code tends to have less bugs since there is less to be buggy).

As am example: we switched from Gnome to Unity. So older releases will have no bugs regarding Unity and newer versions will have lots of them where we still have Ubuntu derivatives using Gnome. So those Unity bugs caused an increases in the bug count.

Ever heard of the error-tracker? It will guide you to errors.ubuntu.com and ...

As an example: up to Ubuntu 18.04 we will probably see the amount of bugs double. We will not only have the "old" Unity7 but also the "new" Unity 8 to deal with. A completely new desktop experience that will have its own style of problems (aka. bugs).

To add to the interesting links list: bugs launchpad has a list of bugs with tags on them. It also includes bugs specific to a release (most bug are probably not specific to a release):

57 zesty
2346 yakkety
3043 xenial
2382 wily
4415 vivid
37 utopic
2724 trusty
1 saucy
1995 precise

If you look at this the amount varies a lot between releases. Yakkety is doing pretty good compared to Xenial and Vivid.

Solution 2:

If we could count the number of bugs per Ubuntu release (... 10.04, 10.10, 11.04, ...), would it be a decreasing line?

This would tend to decrease, but this is software development we're talking about. So, let's talk a bit about software development.

• Software development is not a science! It's an art!
  When someone writes software, they're making guesses. They're trying things out. They're coding normally, which (unfortunately) tends to create bugs that nobody was able to expect or see. There's no way to guarantee that any piece of code is bug-free, at all.

• Software developers are human
  "To err is human," as the saying goes. Humans aren't perfect. They make mistakes. They forget to change a variable. They fail to see a weird trigger that will cause Ubuntu to crash.

• In this case, software development isn't life-or-death
  Ubuntu comes with the ability to update itself. There isn't the same "Oh god, this needs to be 100% bug free and tested because it can never be changed ever again" mentality. It's okay to make mistakes, because they can be fixed later. While this isn't an excuse to intentionally neglect bugs, things may slide through due to testing not covering a weird edge case that turns out to be pretty common. Other times, the edge case is so edge that maybe two people in all of history will ever trigger that bug.

Is not the whole point of new releases to fix previous issues?

New releases include new features and bugfixes. Unfortunately, new features also mean new bugs.

Can we not dream of a flawless Ubuntu LTS?

We can dream, but only that. It's code, written by humans. It's not perfect, and is never perfect. No program, especially something as complicated as Ubuntu can ever be flawless.

You can even visually see this effect on the Error Tracker. Upon every release, the number of errors caused by bugs or various skyrocket, until various patches and bugfixes bring them back down to manageable levels.

TL;DR: Sorry, bugs are part of software development.

Solution 3:

If each ubuntu stayed on the same versions of its component software then you could assume a downward trajectory in the amount of bugs, however changes are made to add functionality in the various packages that comprise ubuntu, therefore new bugs arrive with every change.

Not all bugs are solvable, some under closer examination split into more bugs and some collapse into less, lots of them don't even it make it to a developer because they are not well described or repeatable enough.

Another factor is that the user base is growing, this means more potential for finding bugs (more usage time) but doesn't increase the resources for resolving them as it doesn't equate to more developers.

Yet another factor is that ubuntu runs on a very diverse platform that changes constantly, some bugs are related entirely to hardware quirks that are not ubuntu's fault.

As a professional Software QA i can tell you there cannot be software without bugs, the best you can get is to prove that the things you want to do with some code do not trigger bugs. Zero bugs (in a non-trivial project) is a philosophical impossibility for many reasons, the strongest being that perfection is impossible within time and space, if it where it would have happened already and be abundantly obvious if it was possible. Another reason is that the difference between a bug and feature is in the eyes of the beholder, what you call a bug might be feature to the developer and vice versa.

This does not mean i think ubuntu distros are of low quality, far from it, they realistically approach the compromise between new functionality and stability in a way that most commercial OS'es could only dream of. The graph posted by rinzwind is impressive in that despite all these major challenges the vast majority of bugs reported are handled and usually resolved.

Solution 4:

The number of bugs reported is based upon:

• more lines of code = greater chances of a bug. Ubuntu is based on the Linux Kernel which as grown from 150 thousand lines (version 1) to 17 million lines (version 4.5.4).
• more users = greater number of potential hardware / software pairings resulting in bugs
• more users = greater chances of reporting bugs. If bugs are only reported 20% of the time and 5 users encounter it it may not get reported. If 50 users encounter it (due to larger user base) it will be reported.
• new hardware = more bugs. We see all kinds of bugs with Intel Bay Trail processor, nVidia cards and Radeon cards. This will only increase with 4k TV, USB 3.1 and whatever new hardware developments are on the horizon.
• More hardware = more chances of conflicts. Each new device may bring its own device driver / kernel module. More modules = more chances of two clashing against each other creating a bug.
• More software = more chances of conflicts. As the user base grows so does the volume of software developed for them. Apache Open Office can conflict with Libre Open Office and some might choose to install both because storage space is so abundant at lower prices. There might be 5 programs available now to control fan speed and a user might install more than one and they might conflict with each other causing system micro freezes every 10 seconds.

Keep in mind that as the number of bugs are increasing so are the number of people fixing them and users sharing solutions/answers with others.

Additionally in some cases the number of bugs didn't increase but the number of people encountering them increased. Also as stated earlier the number of people reporting bugs has increased.