What is and isn't a bug in software
In response to my entry on how systemd is not fully SysV init compatible because it pays attention to LSB dependency comments when SysV init does not, Ben Cotton wrote in a comment:
I'd argue that "But I was depending on that bug!" is generally a poor justification for not fixing a bug.
I strongly disagree with this view at two levels.
The first level is simple: this is not a bug in the first place.
Specifically, it's not an omission or a bug that System V init
doesn't pay attention to LSB comments; it's how SysV init behaves
and has behaved from the start. SysV init runs things in the order
they are in the
rcN.d directory and that is it. In a SysV init
world you are perfectly entitled to put whatever you want to into
your script comments, make symlinks by hand, and expect SysV init
to run them in the order of your symlinks. Anything that does not
do this is not fully SysV init compatible. As a direct consequence
of this, people who put incorrect information into the comments of
their init scripts were not 'relying on a bug' (and their init
scripts did not have a bug; at most they had a mistake in the form
of an inaccurate comment).
(People make lots of mistakes and inaccuracies in comments, because the comments do not matter in SysV init (very little matters in SysV init).)
The second level is both more philosophical and more pragmatic and is about backwards compatibility. In practice, what is and is not a bug is defined by what your program accepts. The more that people do something and your program accepts it, the more that thing is not a bug. It is instead 'how your program works'. This is the imperative of actually using a program, because to use a program people must conform to what the program does and does not do. It does not matter whether or not you ever intended your program to behave that way; that it behaves the way it does creates a hard reality on the ground. That you left it alone over time increases the strength of that reality.
If you go back later and say 'well, this is a bug so I'm fixing it', you must live up to a fundamental fact: you are changing the behavior of your program in a way that will hurt people. It does not matter to people why you are doing this; you can say that you are doing it because the old behavior was a mistake, because the old behavior was a bug, because the new behavior is better, because the new behavior is needed for future improvements, or whatever. People do not care. You have broken backwards compatibility and you are making people do work, possibly pointless work (for them).
To say 'well, the old behavior was a bug and you should not have counted on it and it serves you right' is robot logic, not human logic.
This robot logic is of course extremely attractive to programmers, because we like fixing what are to us bugs. But regardless of how we feel about them, these are not necessarily bugs to the people who use our programs; they are instead how the program works today. When we change that, well, we change how our programs work. We should own up to that and we should make sure that the gain from that change is worth the pain it will cause people, not hide behind the excuse of 'well, we're fixing a bug here'.
(This shows up all over. See, for example, the increasingly aggressive optimizations of C compilers that periodically break code, sometimes in very dangerous ways, and how users of those compilers react to this. 'The standard allows us to do this, your code is a bug' is an excuse loved by compiler writers and basically no one else.)