3

If the bug is fixed in a newer (Testing or Unstable) version of the package, is there any hope that the fix might make it down to Stable before the next major release? I imagine not, unless it has severity Grave or the like.

Is it actually helpful to the developers working on versions that are perhaps two or even three years newer? I would like to be as helpful in bug reporting as I can, and to that end, I would like to set up a Sid installation in a virtual machine so that I can try to reproduce my Stable bugs before reporting them, but even if the bug is still present in the newer version, will the developers actually pay much attention to a bug reported against Stable?

I guess there's a lot of additional, fuzzier questions around this that I can't quite put into words - but basically, I would love to hear from some developers if I'm just pestering them or if reporting bugs against old packages is actually helpful.

2 Answers 2

0

To first clarify, there is a difference between a distro (binary) package and the original source package. While some distros break repositories into, e.g., "testing", "unstable", and "stable", and some developers also maintain a "stable", "unstable", "nightly", etc. version, these are not the same (but the version numbers do correspond).

Also note that "source package" here does not refer to the distro's -src package. It refers to the original source distributed independently of the distro. I.e., these are packages you usually don't use directly -- the distro repackages them into their binary (and -src) form.

For example, I maintain the original source for foobar; the current stable source package is 1.2.4 and the current unstable source package, 1.2.5. Debian (not me) packages this for distribution; their current stable repo version is 1.2.3 and their current testing repo version is 1.2.5. I (the original developer) am not responsible for the debian package, or which source version is in which repo package. I don't do the compiling or the packaging of the distro binary version. I just maintain the original source.

Bug reporting for these is also separate. As the original developer, I may or may not read and respond to bugs reported on a distro package. If not, and the issue should concern me, then the distro packager will file a report on the original source.

If the bug is fixed in a newer (Testing or Unstable) version of the package, is there any hope that the fix might make it down to Stable before the next major release?

Fixes are very seldom back-ported, meaning, if your distro stable package is 1.2.3 and you know 1.2.5 has a fix, then unless the next distro stable is 1.2.5, it will not contain the fix. I.e., if the distro releases 1.2.4 as the next stable, the fix from 1.2.5 will not be back-ported to it, so the bug will still be there.

Bugs which relate to the source (WRT to binary packages, sometimes they may not) require the source to be fixed by the original developer in a new release, then this incorporated into the corresponding version of the distro package. There are some exceptions to this as distros will sometime patch things themselves and add a suffix to the version to indicate (e.g. 1.2.4-1) although not, I think, in cases where the fix is in a subsequent version of the source.

Is it actually helpful to the developers working on versions that are perhaps two or even three years newer?

That depends on whether the bug has been fixed or not. The point of versioning is that it is fixed -- you do not change version 1.2.3 after it is released, no matter what. If you fix something in 1.2.3, that fix will appear in the next release. If it's something that's been broken for years, that release may be 1.2.6, etc.

So if you know something is fixed in a later version of the source, then yes, reporting it to the original developers is pointless. However, if it is the current stable used by your distro and the bug has not been reported there (remember, the bugs reported for the source and for the package are not the same) then you should report it, and indicate that it is fixed in a later version of the source. Again, remember that the people responsible for distro packages and their bug reports are not the same as the original developers. So although I may have already fixed the problem, the distro packagers may not know or care. Although they likely will have kept themselves informed, by reporting the issue to them (not me), you've explicitly raised it to their attention, which may motivate them to upgrade the stable package (different distros use different criteria for this).

0

First, bug reporting is generally a good idea, even if it is often thankless work, like lots of things in free software.

To take your questions in order,

If the bug is fixed in a newer (Testing or Unstable) version of the package, is there any hope that the fix might make it down to Stable before the next major release?

Probably not. Typically backported fixes to stable are for security purposes only.

Is it actually helpful to the developers working on versions that are perhaps two or even three years newer?

If you find a bug in a stable version, the first thing you need to do is to try to reproduce it for the current version of that software, or at least a more recent version. Often that will be available in unstable, so you can try to backport the unstable version to stable, or just test it on an unstable system. If the bug can be reproduced on the unstable version, I usually check with the project mailing list as to whether others can reproduce it. Sometimes I just report the bug.

Bear in mind that even if the unstable version is the most recent release, the bug may be fixed in the development version, so unless you are testing the current development version of the software (typically available only from the software repository), you can't be certain the bug has not been fixed. However, I am often too lazy to test against the absolutely bleeding-edge code, partly because it has not been packaged, and I like to work with packaged software. But YMMV.

If the bug has been fixed in a more recent version of the software, I usually don't report it. In theory one can do so, but the upstream developers certainly won't care, amd the Debian packagers of the software are also very unlikely to care.

Finally, you write:

but even if the bug is still present in the newer version, will the developers > actually pay much attention to a bug reported against Stable?

I don't understand what this means. If the bug is present in a newer version, report it against the newer version. Why report it against the stable version?

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .