This was written sometime in 2004, I think

How does the maintainer of a free software project decide which features to
add? The guiding principle is simple: ask “why,” rather than “why not.”

Let’s start with some mails from Linus Torvalds on the subject,
since people are more likely to listen to him than me:
here
and here
(local mirror if the links died).

All code is presumed harmful, because it will have bugs and
maintenance costs, and introduce behaviors that will interact with other
features. One feature often precludes or simplifies the implementation of some
other feature, and these interactions can be unpredictable.

The basic job of a maintainer is to keep things on track, taking a
long-term view. In practice this means saying “no” a lot.
How do you convince a maintainer to add a feature? Provide a rationale
which:

• Does not apply to all possible features.
• Contains facts or empirical data rather than speculation.
• Demonstrates that you’ve done your homework on alternative
  solutions to the same problem.

• Demonstrates that you know what the root problem actually
  is; what motivates the feature? How else could it be approached?

• Demonstrates that you’re thinking of all users in the big picture,
  instead of just yourself and people like you.

• Improves things for a large percentage (50%?) of users, or makes the
  impossible possible for a smaller percentage (5%?). “Easy things easy,
  hard things possible.”

• Shows that the feature is genuinely important enough to be worth
  maintaining some extra code.

Bad rationales which apply to all possible features include:

• Some other operating system had the feature.
• Some (unknown number of) people might like it (for some
  unknown reason).
• “But the feature doesn’t hurt anyone who isn’t using it.”

These rationales a priori don’t count, because allowing all
possible features destroys the software. Software can’t be infinite in
size. All rationales must draw a line between what’s in and what’s
out.

Important homework for any feature:

• What do other operating systems do?
• What other approaches were considered and rejected?
• Who else have you talked to and what did they say?
• Is the feature already present in custom vendor-specific patches?
• Are there any applicable standards?
• If the feature is performance-related, what is the current
  performance, are performance problems user-visible, and what are the
  possible gains?
• How does the feature interact with other features?
• Were there any mailing list threads?
• What does the UI team think about the UI for this feature?
• Is the feature designed around user concepts and goals or the implementation
  details of the software?

Please don’t assume that the key issue for accepting a feature is whether
there’s a patch. It isn’t. It’s easy to write a patch. It’s hard to maintain a
software project over the long term. Maintainers absolutely have to
understand the rationale for each feature, not just rubber stamp the
patches. If they don’t understand a feature they can’t maintain it over
time. There will be future decisions about how the feature works, or how related
features work, and the maintainer will have to make those decisions.

Thus the maintainer must understand why the feature exists, in detail.
If they just take your word for it, they aren’t doing their job.

See also this argument,
specifically the part about preferences, which are especially likely
to have poor rationales.

Please don’t bother flaming maintainers because your feature hasn’t
gone in yet. Provide better rationale, yes. Randomly flame about the
fact that maintainers have to say “no” a lot, no. Design by committee
is far, far worse than rejecting a couple of patches. As Linus says,
“If you don’t get it, don’t bother emailing me.”

Special bugzilla rule: if you move a bug from WONTFIX or NOTABUG to REOPENED,
you had better add additional, quality rationale at the same time.

Here’s one way to look at it: If you’re too lazy to do the homework and think
through the big-picture rationale, I’m too lazy to add the feature. On the other
hand, patches that come with well-thought-through rationale are often applied
right away.

In addition to saying “no,” maintainers have a couple of other
obligations in my opinion:

• In the presence of good rationale, maintainers should be willing
  to change their mind often.

• If you want to provide your own patch set or distribution of the
  software with different features, the maintainer should not complain.

Making your own patch set or distribution is often a good way to
demonstrate that a feature is useful and build the case for including
it in the mainline. (Caveat: external interfaces/APIs should be
marked as nonstandard or vendor-specific in some way, if included in a
nonstandard distribution. e.g. if you create a nonstandard function,
call it yoyodyne_extension_blahblah(), not
standard_namespace_blahblah().)

Of course, if a custom patch set or distribution is only of
interest to 1% of users, it should conceivably stay custom forever,
instead of being merged. But if it proves its worth for a good number
of people, probably it should be merged.

Will maintainers make mistakes? Yes. But occasionally screwing up
the exact line between accepted and rejected patches is a much lesser
evil than taking every patch immediately would be.