On Fri, Jan 18, 2002 at 09:28:44PM +0200, Shlomi Fish wrote: > > In that case, maybe we should make sure that the code is: > A. on CVS. > B. Every sub-system maintainer can commit patches to his own subsystem > without asking Linus. > > Making everything pass through one person is very unscalable.
Development of OS code is unscalable by its nature. The pieces can be highly and dynamically interdependent, so they need to be contrasted and syncrhonized. Linux has a bottom-up development model -- people keep on suggesting patches, some of them good, some of them bad, and many of them conflicting with one another. Those patches float through other subsystem maintainers or maintainers of independent trees if they're any good, and the final station is Linus's tree. This is very different from a top-bottom model where the top guy pronounces what needs to be done, and the maintainers break up the task and make it more detailed, until it gets implemented and committed into the CVS tree. In the top-down model the general direction comes from the head of the project, and only later do we see code implementation. In the bottom-up model, the project maintainer hardly ever has to think about new ideas because they keep on being suggested from the bottom, but (at least in Linux) these ideas would not even be considered until there is actual code to discuss, usually also benchmarks to compare, and at times even positive reviews from a large user community. In the bottom-up approach, the main task of the project maintainer is to select patches for inclusion based on his understanding of the code and the needs. Thus, eliminating Linus's role as the patch selector still will not solve the essential problems. Linux is not like Debian, which has thousands of packages and where, on the most part, the only communication needed between developers revolves around standardization. In Linux, every part affects everything else, and the solutions are very rarely obvious. The division of responsibility is often much fuzzier. For instance, even though the kernel now contains the VM developed by Andrea Arcangeli, some of the improvements for it ("the rmap patch") that have seen best reviews so far are by Rik van Riel, no less. Alan Cox has accepted it into his tree and if they continue to receive good reviews I would not be surprised if they show up in Marcelo's and Linus's as well. That is, there is no one "VM maintainer" in Linux, but there are several VM hackers and interested people, who debate and argue and offer conflicting patches, with Linus being the final arbitrer. Now, there are other subsystems that are more independently run. The VM and the scheduler are the ones that are the most central to the OS and the ones for which it makes less sense to have a single maintainer, and indeed there isn't one. Drivers are on the opposite side -- they are so numerous and the interfaces to them are so relatively stable that who is their maintainer is never in question. Indeed, Linus usually accepts patches from driver maintainers immediately, and was even criticized for the inconsistency and lack of quality of driver code compared with rest of the kernel (mostly by Alan Cox). Filesystems are somewhere in the middle. > Like I said the maintainer of a subsystem will have commit access to his > subsystem. It makes no sense that the maintainer of, say, the ext3 > filesystem will have to pass his patch to Torvalds first. He can simply > commit it into his tree in the CVS (or BitKeeper, or Subversion or > whatever) ..Or just have Linus automatically accept patches from maintainers. You can separate the social organization from the technical means used to implement them, because they are completely unrelated. The "Linux patch acceptance path" is not slow and unreliable because Linus's mailer sucks, but because Linus reviews each patch and often rejects or ignores patches that he doesn't like. Don't blame the mail, blame Linus's maintainership. And by the way, filesystems -- especially ones that introduce new concepts, such as journalling -- can often have global ramification, because they define new interfaces and new methods to do things that will be referred to and become difficult to get rid of. Another thing is that it is desireable (as Alan Cox often says) to avoid putting in two changes that are somehow in contact at the same time, because it makes debugging difficult. For instance, if you put in a filesystem update and an IDE update at the same time, and then someone reports a filesystem corruption bug under rare circumenstances, good luck trying to hunt it down. If you put in those changes one at a time, at least you can be sure where the bug is. For all those reasons Linus might want to reject or postpone an ext3 patch. > > - How to resolve disagreements between different maintainers > > You probably mean on something that affects the whole kernel. I suppose > Linus should have the ultimate decision. However, I believe he should > designate other people who could make such decisions in case he has not > voiced it for a long time. Either he makes the final decisions, or he doesn't and someone else does. I don't understand what you mean by what you suggest and what it would achieve. > I believe Linus is making the same mistake Moses did (if anybody remembers > that story from the Bible). He thought every Israelite should address him > on every little matter. But then Jethero suggested him to have the Sarey > Alaphim, Sarey Meoth, etc. system, where problems were handled at a lower > level. It's done this way, sure. But a balance is important. If Linux is too centralized, we risk slow development and developer discontent. But if it is too distributed, we risk unclear and inconsistent code, unclear and inconsistent behaviour, bad, untested or unnecessarily controvertial changes, subtle bugs on the interfaces between components, and therefore increasing difficulty in extending the system. Finding the right balance is tricky. > > - How to decide the general direction of the kernel > > I don't have a problem with Linus deciding it. If anybody has problem with > what Linus decided, he should fork and create an alternative kernel. Linus says that "the real world is dominated by implementation details" (I don't remember who he was quoting), so the correlary is that Linux's general direction is dominated by its source code. > Perhaps Linus should write a manifesto of the Linux kernel. Tell about its > philosophy, etc. In any case, everything cannot pass through one person as > is the situation now. This changes constantly. If you could write such a manifesto that will remain unchanged for more than a few months then there would really /not/ be a need for Linus. > > Once such an alternative project management is sorted out and > > working, then whetehr it actually uses CVS for its sourse code > > management is only of secondary importance. > > > > I disagree. A CVS can help the different maintainers work on the same code > base, while not interfering with the other ones' work. No. Good interfaces, good understanding between the developers and a clear division of responsibility do. If you don't have that, no source control system will help. > As you see everything can be resolved with a little amount of reasoning. > Do you think that the President of IBM or Intel or (god-forbid*) > Microsoft, should be involved in any of the decision each one of its > engineers make? I don't think so, and neither should Linux. It has reached > the state where it's impossible to pipe everything through one person. > (and this time - the UNIX pipes analogy is perfect) Linux's mode of development is very, very different from Microsoft's or IBM. If I am following your line of reasoning correctly: Linus's role is to apply patches from maintainers to the main tree, and he's doing a worse job than CVS. CVS is provably able to apply 100% of the patches from maintainers, and therefore if Linus is known to drop patches he is doing suboptimal job. I believe Linus's original analogy was "CVS with taste", that is, he will only accept good patches and drop the bad ones. If Linus accepts a bad patch it is just as bad as not accepting a good patch. Anyone can fork the code, and many people did, and do, and distributions can choose other forks and apply other patches. The power that Linus holds is to be able to say "but /this/ is the set of patches that /I/ believe in and think they should be the basis for future growth". If he doesn't approve of the patches himself, he can't do that. (And if this role is not needed, then we wouldn't be having this discussion.) You can say he's doing a lousy job, though. > I guess I'll rename the mutiny to the "Great Linux > Kernel Meta-Reorganization Mutiny", of which CVS/BitKeeper/SBV would be > just one of its proposals. I don't think you are completely clear on what this meta-organization will look like. You will have a hard time getting any of the kernel hackers to even listen before you can show why it will work better. No doubt Linus's handling of the 2.4 series was problematic, he admitted so himself, but I can't see how what you suggest could solve the specific problems that 2.4 had. ================================================================= To unsubscribe, send mail to [EMAIL PROTECTED] with the word "unsubscribe" in the message body, e.g., run the command echo unsubscribe | mail [EMAIL PROTECTED]