In response to recent comments in our code review tool about whether
some extensions should be merged into core MediaWiki, or not. I would
like to try and initiate a productive conversation about this topic in
hopes that we can collaboratively define a set of guidelines for
evaluating when to move features out of core and into an extension or
out of an extension and into core.
<unintended bias>
Arguments I have made/observed *against* merging things into core include:
1. Fewer developers have commit access to core, which pushes people
off into branches who would have otherwise been able to contribute
directly to trunk, inhibiting entry-level contribution.
2. Extensions encourage modularity and are easier to learn and work
on because they are smaller sets of code organized in discreet
bundles.
3. We should be looking to make core less inclusive, not more. The
line between Wikipedia and MediaWiki is already blurry enough as
it is.
Arguments I have made/observed *for* merging things into core include:
1. MediaWiki should be awesome out-of-the-box, so extensions that
would be good for virtually everyone seem silly to bury deep
within the poorly organized depths of the extensions folder.
2. When an extension is unable to do what it needs to do because it's
dependent on a limited set of hooks, none of which quite do what
it needs.
3. Because someone said so.
</unintended bias>
<obvious bias>
I will respond to these three pro-integration points; mostly because I
am generally biased against integration and would like to state why. I
realize that there are probably additional pro-integration points that
are far less biased than the three I've listed, but I am basing these on
arguments I've actually seen presented.
1. This is a very valid and important goal, but am unconvinced and
merging extensions into core is the only way to achieve it. We
can, for instance, take advantage the new installer that demon is
working on which has the ability to automate the installation of
extensions at setup-time.
2. This seems like a call for better APIs/a more robust set of hooks.
Integration for this sort of reason is more likely to introduce
cruft and noise than improve the software in any way.
3. Noting that "so-and-so said I should integrate this into core" is
not going to magically absolve anyone of having to stand behind
their decision to proceed with such action and support it with
logic and reason.
</obvious bias>
If we are to develop guidelines for when to push things in/pull things
out of core, it's going to be important that we reach some general
consensus on the merits of these points. This mailing list is not
historically known for its efficacy in consensus building, but I still
feel like this conversation is going to be better off here than in a
series of disjointed code review comments.
- Trevor