Is Linus’ Law still valid?

A few weeks ago my Fedora Linux computer became so damn slow that I had to urgently ask for help.

Things are better now, thanks to the valid help I promptly got from the community. However, I would like to share why, after making all that noise and then disappeared for a few weeks. I think there is a general issue here that is relevant to everybody who wants to promote Free Software. I think that the so-called Linus’ Law, the one that says “given enough eyes, all bugs are shallow” is much less of a selling point than it used to be and that what happened to me may be a good example of this point.

I have done professional hardware and software testing in my previous jobs. I know how to do it well. In these weeks I have obviously come across several, more or less unrelated software bugs some serious, some just irritating. Only part of them are in closed source software, so even if all software were “Free as in Freedom”, it wouldn’t change much of what follows.


When I asked for help, I did get plenty of it (THANKS!, again) but it tooks days for me to start trying all the suggestions I got. I did the bare miminum to get my system up and running decently again. I didn’t do any real testing and bug reporting though. And now, that is as soon as my computer is back to decent/good performance, I will almost surely have to go on, without contributing to solve those bugs for good. Without having even tried all the suggestions I got for free.

Am I ungrateful? No, I really don’t feel ungrateful. I am certainly grateful to people who made and make Free Software possible in general, and to all people who sent me free advice in this specific case. And I still love and only use Free Software, both for ethical reasons and because it still is (regardless of software licenses) what works for me much better than the alternatives.


As I said, personally I have the skills to test software programs and work together with its developers (unlike most newbie Linux users, who would have gone back to Windows one hour seeing their computer becoming disgustingly slow). This only makes my doubts about Linus’ Law stronger: I could not make the bugs I met shallower, even if I have the skills to do it.

However, it doesn’t matter what skills I have. As many Linux Free Software users who aren’t programmers, I simply have no time or spare computers to do any real software debugging. Debugging for good the software bugs I met three weeks ago and later means to have lots of time to spend doing debugging and nothing else. Even if you do have a spare computer to reserve for testing, which isn’t my case right now: if I test, I don’t work.

I could only afford that much time to help make bugs shallower if I were paid to spend that time in that way. It’s as simple like that, really. I’m not asking money, of course! I am just pointing out that I don’t simply prefer to do other things: I must do those other things, instead of helping to properly debug software, because I have bills to pay.

When I asked for help, I could not use it immediately because I had a deadline that I could meet even with an almost dead computer, because involved talking to people or writing plain text files. Only after I closed that assignment, I went back debug my computer. But as soon as its performances improved from “almost dead” to “bad, but much better than before, ie bearable” with the Firefox VACUUM trick, I immediately stopped worrying and investigating. Because I had other deadlines to meet by doing urgent stuff that my computer now was fast again to do. It didn’t matter if the solution was an ugly, partial, unlelegant patch and what not. It is good enough. I will indirectly pay back for the help I got, in the only way I’m able to do it. I’ll reformat in one, quickly readable list all the tips I got from comments to my posts, mailing lists and private message and publish them, as soon as I can.


But I wonder if that Linus’ Law is really as effective today as it was 10 years ago. Today Free Software is much richer and more complex than it was in the 90s. Things in the server/developer space, from the Linux kernel to Gcc or Apache, are rock solid. The situation on the desktop is different, and made worse by the fact that the majority of current users of Free Software desktops are people like me. We run Free Software to do stuff, not because we like to hack Free Software. Assuming we have the skills, and that’s one damn big assumption, we often must run all day to do things that require a computer, but have nothing at all with debugging software, and don’t leave any time for it. Sure, we’re so many that we will stump into a huge number of bugs anyway, whether we want it or not, but that will be it. But is it realistic to expect, or keep telling, that this will be enough to fix those bugs quickly?


Share

32 thoughts on “Is Linus’ Law still valid?

  1. Pingback: Flash/nVidia horrors, Gnome/KDE fights in my Fedora 14 | Free Software Tips and Tricks at Zona-M

  2. Pingback: Update on: Why is my Linux so damn slow? | Free Software Tips and Tricks at Zona-M

  3. Pingback: Links 2/3/2011: Linux Everywhere, GIMP 2.8 Plans | Techrights

  4. Riccardo Corradino

    In my opinion the decisive act which can mark a turning point for the survival and the increase of diffusion of the OSS is the formal constitution of organizations (no-profit organization at least), because the interest in the ethical aspect is diminishing just like the patience and the availability to deepen the computer knowledge in terms of time and energies.
    Without a diffuseness of organizations structured to support its diffusion the few dedicated machines producers will be forced leave this segment of market.

  5. Shocky

    Your conclusion is not valid. You are saying the rule “if A then B” is wrong because A is not true. The rule still stands, it’s the premise that’s not true. Linus’ law is that “given enough eyes, all bugs are shallow”. Then you go on to say you don’t have time to look at it, the same as many others (and I often find myself in the same boat). That just means there aren’t enough eyes, not that the law is invalid. Your eyes don’t count toward that law if you aren’t looking at the code. There is undoubtedly a shortage of eyes on many FLOSS projects.

    1. marco Post author

      Shocky,
      I see your point. Should I have said “still applicable” instead of “still valid”? What is certainly not true today is that “lots of users = lots of eyes that see the bugs”, but there are many FOSS advocates that behaves as if this were the case. It was in the 80′s/early 90′s, when most computer users were also professionals or enthusiasts, not today for sure. Another reason why I have this doubt is that I have gone so far to investigate my recent problems, that is even if I did nothing to really solve those bugs, I saw more or less what and where they are, but only because I REALLY wanted to know more. Most other users would have simply changed distro or gone to Windows at the very first sign of the problems I had, without caring at all to see in which general area the bugs could be

      1. Jose_X

        Besides what was stated by Shocky…

        You don’t know if this problem has been solved in this time period or will be solved now aided by the steps you took to address the question. It might just be a problem that will take a while to sort itself out.

        You also picked one example that failed. That is not a survey.

        An analogy is with a potential patron to something (a contributor of cash in other words). You might feel that you can’t give that much to very many things you’d like to help, but that doesn’t mean the model doesn’t work. If you give a few bucks to a few recipients while failing 1000 times, you still have your contribution average multiplied by potentially hundreds of thousands if that many others are participating. In the end millions of dollars are raised despite you failing so badly.

        Isn’t it amazing that we hardly contribute to FOSS (even those of us who are skilled), yet a vast ecosystem of FOSS provably exists and is accessible to us?

  6. Jeff Darcy

    I don’t think “Linus’s Law” was ever valid. Most people only use a small percentage of the functionality in any non-trivial program, and most developers can effectively work on an even smaller percentage. Take, for example, four highly demanding specialties: storage, compilers, distributed systems, and scientific computing. Less than 1% of developers can claim serious expertise in even two of these, and I can pretty much count on one hand the number I’ve met who can claim three. All of these experts would be as helpless as any newbie if a bug appeared in any of the specialties they don’t have, and there are far more specialties I can mention. Even with a random distribution, the marginal probability of user N+1 even using new functionality, let alone being able to fix bugs in it, drops pretty close to zero after N reaches the small hundreds. Factor in the self-selection and interest grouping of users that actually occurs, and the decline is even faster. This was *always* the case.

    More eyes don’t make bugs shallower. After a while, they don’t even increase the chance of any particular shallow bug will be found or fixed, and the bugs that are hidden deep down in the muck at the bottom of the pond will remain just as inaccessible. It’s like prospecting for gems or fossils. More eyes won’t help. The only way to find the deep bugs is to have the right eyes, trained in what to look for and assisted by the right tools to focus that search. That’s why the majority of the work on the most challenging kinds of open-source software is done by full-time paid professionals (like Linus himself), whether they be regular employees of or consultants to the people with money to fund that work. Again, this was *always* the case.

    Disclaimer: I work for Red Hat, though these are not Red Hat’s opinions. They’re personal beliefs I’ve held and publicly stated (see my blog) since long before I came here.

    1. marco Post author

      Excellent reply, Jeff. Thanks for explaining well something I agree with, but wasn’t able to express so clearly. I believe that the Gnome/Kde interaction problems I describe in my other post on Gnome/KDE fights are good examples of the bugs whose probability to be solved doesn’t increase with the number of eyes who see them. Because I can’t believe I’ve been the first to see those problems this month.

      1. Warren P.

        I think Linus’ law is not a law. It’s a theorem. It’s not 100% true in 100% of cases, nor 100% false, but rather, observably true in a large number of cases. It is a premise, a theorem, with a strong power of explaining why open source is a powerful concept. Is this process perfect? No.

        Linus’ Law has more alliterative power, and thus we bend the word law. It’s a powerful idea. A theorem. As yet unproven, but with a lot of strong evidence in its favor.

        W

    2. Ulrik Mikaelsson

      Remember there’s a difference between “more eyes DON’T make bugs more shallow”, and “open source doesn’t imply more eyes”. The arguments presented here are of the second kind, and I’m inclined to agree BUT, why shouldn’t the “full-time paid professionals” count?

      Open Source was never JUST about the hobbyist. The business-strength of open source is that of low-overhead business cooperation in mutual interests, giving thousands of paid developers around the world the opportunity to work on the open source ecosystem. Their eyeballs count too, and without them I certainly think things would be more bug prone.

      On a side-note, I still think it is important to look for incentives to user feedback. Perhaps some kind of gameification would give the right incentive.
      - “Look, I got a bronze-badge for submitting two bugs on Natty before launch!”
      - “Yeah? I got a silver badge for fixing one”
      - “Sucker, I just had to reproduce in a VM and give developers SSH-access for my silver badge”

      Look at the StackExchange-sites, for example.

      1. marco Post author

        Remember there’s a difference between “more eyes DON’T make bugs more shallow”, and “open source doesn’t imply more eyes”

        Ulrik,
        this seems to me more or less the same thing I’m trying to prove with this and the related posts. Personally I agree that there is a difference. I’ve written these pages just to point that there IS a difference, at least when it comes to software that, unlike Apache, is by definition most used by non-programmers.

        1. Jose_X

          Remember that people move on.

          For example, there are many non-apache web servers that are probably attracting a relatively higher proportion of eyeballs today than was the case in the past.

    3. Jose_X

      >> All of these experts would be as helpless as any newbie if a bug appeared in any of the specialties they don’t have, and there are far more specialties I can mention.

      You are falling for the trap of not recognizing how advance happens.

      If I report a bug, even if I report to the wrong person the wrong bug with the wrong guess of a solution, I have very possibly increased the odds that a solution will be found. [I'll skip doing a hypothetical butterfly effect simulation since I'm sure you know what I mean.]

      Also, you are ignoring the fact that people do learn. Do you honestly think that an expert in supercomputing cannot become very competent in databases at least enough to figure out where something breaks?

      You are pretending that an expert in one area of computer science is likely a “noob” in most others. That is nonsense. Most of the tools that might work in one environment can be used in many others. We are still using the same mathematics and logic and probably a language with overlapping features. No expert in any field is clueless of matters in another. They just aren’t the creme de la creme in those other fields..

      ..though they might become one actually trying to diagnose an important bug. To be more specific, perhaps no one is an expert in the particular full context where a particular failure occurs, but that person diagnosing the problem might be closer to becoming an expert than anyone else on the planet, at least after some research and study. Much expertise is localized.

      >> Even with a random distribution, the marginal probability of user N+1 even using new functionality, let alone being able to fix bugs in it, drops pretty close to zero after N reaches the small hundreds.

      Can you elaborate or rephrase this?

      And I hope you aren’t assuming that all decreasing infinite series converge to a small number. [common example: 1/10+1/11+1/12+1/13+... "adds up to infinity" (ie, diverges as the number of terms approaches infinity).] What this means is that even if some marginal contribution was going down as users were added, that doesn’t mean you aren’t coming closer to resolving any given problem.

      Details matter a lot — that is the key. It has nothing to do with more eyes not helping, rather as Shocky stated, it might just be that we don’t have enough eyes [working properly] for that particular problem, or, more to the point here, the extra eyes and effort might not be creating synergies of any value and possibly actually leading to net losses or negligible gains. This simply means that implied in adding more eyes (or bodies) to a problem is that we execute adequately to leverage those eyes for gain.

  7. KeithCu

    The Firefox vacuum bug is many years old. It has already been spotted by the community. Therefore, your story is interesting, but it doesn’t falsify Linus’s law (I thought it was Eric Raymond’s). The problem is that the fixes haven’t been made / propagated. The law doesn’t speak about that aspect.

    Free software gets better are more people use it. It will work through these problems.

    1. marco Post author

      KeithCu,
      I forgot to include the link but what I found is that ESR called this “Linus’ Law”. Anyway, the point, or at least the question I’m asking is, isn’t this law, or better the way it’s thrown around by many FOSS advocates to say “FOSS is better, it fixes its bug quicker because given enough eyes etc…”, overrated? Does it really apply to the desktop? If the bugs were noted but the fixes were not propagated, it’s still a defeat of that law, or at least of the standard way to use it to promote the quality of FOSS. No?

      Using your words, my doubt now is just that I’m not sure that “Free software gets better as more people use it”. Not when almost those people are people without the time or skills to make it better, as is the case with desktop software like Firefox, Gnome, KDE or even OpenOffice for that matter. “Free Software would get better as more people who can also fix it also start using it” may be more accurate. That’s how I feel, at least.

      1. Jose_X

        Your criticism applies to all organizations of people.

        An advantage FOSS has is that any expert around the world can potentially contribute at some point in time. The potential is greater and some projects do tap into that more than others. The top people for any given problem likely don’t work in one company or can be hired or contracted. So with FOSS, eventually the best in any area (or 2nd best, etc) can all eventually contribute to their perspective areas.

        >> Does it really apply to the desktop?

        There are many issues.

        First, drivers are key here. With Windows, the load is distributed among a very large number of participants. You do have many eyeballs in that scenario for Windows; however, FOSS can now frequently compete effectively in this department (at least across a wide array of products). However, there are still many secrets where the top expert works for that specific manufacturer, so much of the overall quality we would see for that hardware would depend on whether that vendor picks Linux or Windows to support best. Nvidia has done a great job with Linux (but closed source drivers) despite using a small staff. If hardware was open, the story would be much different.

        Additionally, do not discount the many years of eyeballs that have contributed to Windows.. although this is likely not the most important factor.

        From a design point of view, Linux also started focused on servers rather than desktop.

  8. Chris Carpenter

    Well, first off, you are right in the comment reply you said:

    ‘“Free Software would get better as more people who can also fix it also start using it” may be more accurate.’

    but this does -not- invalidate Linus’s law in my opinion. If you read about the context behind Linus’s law, I believe(if i’m remembering wrong then this whole paragraph is invalid) that he was talking about fixing bugs, and it has just afterward been used in the finding bugs sense as well(Microsoft can claim the finding bugs effect of more eyes, as it doesn’t require source code to find bugs, only to fix them). The concept is that if you have the source code open then there is a higher probability of someone knowing how to fix a given bug. If it is closed then the only expertise you have is the expertise you employ at your company, instead of “the whole world”.

    That being said, we can facilitate getting the knowledge of the bugs from the everyday user to the developer by using and improving automated bug reporting software. This will help get the -right- eyes looking at the bug, and in terms of the source code :).

  9. oiaohm

    Linus Law is one of those horrid things. It is valid to a point. I am talking first hand from one of the most complex open source projects out there. Wine(winehq.org) It also has the fastest release cycle of any open source project.

    Linus Law “given enough eyes, all bugs are shallow”. For wine this is true for regressions and new feature bugs 100 percent true. Sooner a regression and new feature class bug is detected the better it is. Less code built on top of it. Fixing a bug becomes extremely hard as more code is placed on top.

    Pre existing deep core bugs that were created when there was not enough testing. Does not alter 1 bit. Basically if a project was lacking testing and defects go in Linus Law does not alter a thing other than when they are fixed more likely fixed correctly.

    But Linus Law of many eyes does have a downside known to wine. If the fix to a old bug is only close but not right it will be pulled out and questioned. The little bit of hindrance is offset by less code base issues.

    sqlite bug in firefox got past the first level of checking now has code built on top of it. Now has become hard to repair. Basically there is a window of time in development when Linus Law is valid. You miss having enough testing in that time and you are shot.

    1. Jose_X

      >> Pre existing deep core bugs that were created when there was not enough testing. Does not alter 1 bit.

      I think what you are saying is that when that happens those bugs will take longer to get fixed, and ultimately, if it is baked in enough, the eyeballs that came to help will wonder off and help some other project, perhaps taking some of their experiences with them to help those projects better.

      Yes, not all bugs are equally easy to fix, but that says nothing about the general statement. In fact, if 100 eyeballs came determined to fix almost any error, they probably could.

  10. nobodyinparticular

    It is interesting that you should mention Wine. An earlier post mentioned that many eyes were not sufficient, but using the “right” eyes was. Wine was moved along significantly by the right eyes, specifically Google.

    http://arstechnica.com/open-source/news/2008/02/google-intoxicates-linux-users-with-wine-improvements.ars

    Personally, I have been using Linux for over a decade and have been contributing code only for the last year and a half. This is because I lacked the skills necessary to make a significant difference with open software. Now I have the right eyes.

    Marco, you have the right eyes, but lack the time to contribute. That’s OK. When you do have the time in the future, you may decide that you want to work on some code. What is important is that you felt strongly enough about not contributing that you contributed an article and started a conversation.

    Perhaps we should revise Linus’ law to read, “Given enough quality time, software bugs will be minimized.” This aligns with, “The number of known bugs is finite, but the number of unknown bugs is potentially infinite.”

    1. marco Post author

      What I feel strongly about and prompted me to start a discussion is the assumption that growth of FOSS users means automatically “growth of bug fixing capabilities”, because it’s very weak. I like the version “Given enough quality time, software bugs will be minimized.”

    2. Jose_X

      A failure being made is to assume that a very incremental gain at some point (which likely cannot be seen by the chosen observer) equates to zero. Another error is to take these mysterious values (perhaps undetected) and generalize that there cumulative sum is zero or some very small number.

      If the above mistakes were reality, we would not have so much quality software, which in many cases (by those who have had access to proprietary software to test) has been shown to have superior bug count over proprietary counterparts.

      Another problem I noticed is that, when it comes to reverse engineering, special concerns are in play. Not all the system is “open source” by a long shot (eg, wine/Windows and Linux/closed hardware).

  11. wally

    Personal experience: given more eyes, structures get more bureaucratized and less effective . Where, how and exactly in what terms you try to report a bug get defined by somebody else whose motive really is to say something like “That’s Ubuntu’s problem, not ours” or “That should have been reported under #236676565435887676 and you have to register to do that”.

    1. Jose_X

      Note however that there are forks.. ie, many other distros. So the bug fixing frequently happens but “under new management”, if you will.

  12. Helton

    Thank FOSS we “hard-workers” have Live-CDs to keep working as long as there is a living computer around.

  13. asdf@asdf.tld

    Depends who you are.

    10 years ago, linux was predominantly used by developers, admins, programmers, and users who were very technical, as a whole, a very savvy group. At that time, any open source piece of software that grew in popularity had more _savvy_ eyeballs looking at code.

    Fast forward and we’re now back in 2011. Linus’ adage is still true. But you have to define your terms. When he says eyes, he means qualified eyes. When he says shallow, he means that showstoppers don’t stay showstoppers for long. Now here’s the rub. That group of experienced eyes has grow since from 2000 to 2011.

    But what has absolutely exploded is the number of dangerously knowledgeable people that know just enough to get themselves in trouble using Fedora and Ubuntu. They aren’t newbs, but they aren’t helping either. When you’re one of those people, you don’t even understand the concept of dangerously knowledgeable. When you’re no longer one of “those”, you’ll look back and smile.

    Everyone goes through that phase. It’s nothing to be ashamed of, that’s how we learn.

    You’ll notice that no one who uses FreeBSD, Slackware, AIX, Solaris, Gentoo, or programs for a living, generally writes these types of articles.

    I look forward to all of you breaking through to the other side soon.

    Don’t worry, it’ll come soon enough.

    1. marco Post author

      Everyone goes through that phase. It’s nothing to be ashamed of, that’s how we learn….I look forward to all of you breaking through to the other side soon. Don’t worry, it’ll come soon enough.

      ASDF,
      I sincerely think that you’re in for a huge delusion. My point is exactly that what has absolutely exploded is just the number of users who

      1. will never have the time or natural skills or neither of them to ever “break through to the other side”
      2. couldn’t care less of ever “breaking through to the other side”
      3. will never, ever feel guilty or ashamed about not breaking through. I mean, why should they?
      1. Jose_X

        But you are just saying that there are limits to the net numbers. Sure. [A definite upper bound is the number of humans who are alive.]

        To do an analysis and suggest that FOSS is near some sort of max is one thing (I’m not saying I agree with this), but to say that the principle of more eyeballs make bugs shallow is false is a different matter… anyway, at this point this is just repetition of what other have said above already.

  14. Purple Library Guy

    Well, it’s all a matter of proportions. It’s true that early Linux users were *mostly* technically oriented, perhaps even skewed towards technically oriented with spare time to tinker, therefore all being in effect “eyes” for the Linus’ Law definition. And nowadays, new Linux users will *mostly* not fit that description.
    But I’m not totally clear on why that matters. All of us non-technical users don’t particularly help, but we don’t particularly do any harm either; you can’t wear the software out. At worst, some of us know enough to report bugs but not enough to try to fix them–but it’s not like we created those bugs, they’d have existed anyway, just maybe undetected until, as oiaohm says, it’s too late to readily fix them.
    Meanwhile, it’s never an absolute. Some new nontechnical users eventually become more technical, some new technical users with no time eventually find themselves with time, and some new users will still be tinkerers, it’s just not as big a percentage as it used to be. So if you add 1000 new Linux users, sure in the old days that might have meant a few hundred new tinkerers who could genuinely constitute “eyes” contributing to fixing bugs, and now maybe it only means 5 or 10 new tinkerers and/or paid developers. But it’s still nonzero. And nowadays increases in Linux users come in much bigger numbers than they used to.

    What does create a dilution in the number of available “eyes” is that the open source ecosystem of software keeps on growing. But it can only grow proportional to the technical community involved in Linux, not proportional to the growth in users. We non-technicals aren’t fixing bugs, but we also aren’t growing the code base among which bug seekers have to be distributed. Nontechnical users aren’t the problem. Perhaps paid developers as compared to hobbyists must spend more time creating new code and less time as eyes taking on bugs, so a higher proportion of paid developers relative to hobbyists worsens the overall bugginess level of open source software.

    Basically, what we have is a situation where M. Fioretti is bothered that he doesn’t currently constitute an “eye” capable of helping out, and he’s extrapolated that distress way too far. This shows a generosity of spirit. But in fact, far from the situation showing Linus’ Law becoming less applicable, it was shown in operation. M. Fioretti had a problem, he asked for help, many eyes looked, and some found solutions; the bug *was* made shallow. It didn’t happen to do him much good because he personally doesn’t have time to apply the solutions, but it may be that some of these fixes will be used elsewhere, or contributed upstream, and the whole thing won’t have been in vain.

  15. Eric Mesa

    I think the issue is how the phrase has been used in propaganda. I don’t think it’s any less valid than when it was coined if you use it honestly – FLOSS is better because more people are ABLE to see what’s going on and fix it IF THEY WANT TO. But people use this to say that as Linux grows it’ll be better. Not true. Because just because you’re able to see teh source code doesn’t mean you will. Look at all the people that benefit from the fact that Firefox/Chrome are open source. How many of them will EVER look at the source code? Barely any.

    1. marco Post author

      Eric,
      “I think the issue is how the phrase has been used in propaganda”

      yes, this is exactly the issue I have, you summed it up well. Thanks.

Comments are closed.