Wandering Thoughts archives

Linux's great advantage as a Unix is its willingness to make wrenching changes

Unix needs to grow but the problem with its growth is that the first attempts at anything in particular are almost certainly going to be not the right answer and not particularly Unixy (if you're unlucky you get crawling horrors created by people who don't actually care about Unix). In order to grow towards a truly Unix solution to any particular problem, you need to be willing to repeatedly make changes. Often changes will not be an incremental evolution of the previous change but instead someone looking at it, going 'this is not the right approach', and taking an entirely different and better approach.

If you allow yourself no changes, your Unix stagnates or locks itself up in a server ghetto or both. If you allow yourself one significant change but then either stop or only allow small incremental changes to the first change, you are almost certainly not going to wind up with a truly Unixy solution. The only way to really iterate towards a Unixy solution to problems is to be willing to repeatedly make wrenching changes, to throw away all of your previous work on a problem because it turns out to be the wrong approach and try again (with no more guarantee that you've really got the right Unixy answer than before, of course).

This is Linux's great advantage as a Unix: it is willing to repeatedly make wrenching changes, which means it has a chance of iterating to Unixy answers. Linux is willing to try things in the hopes that they will be a step towards the right answer, and then if they prove not to be (as they probably won't be), it'll throw them out and start over again when someone has something better. It's willing to do this even when the changes involve significant disruption.

There are downsides to this, of course. Repeated changes create churn and many of the changes are not entirely good ideas (and some are really bad, or just bad hacks). But it beats stagnation, which is the other actual alternative.

Unfortunately I don't think any other current Unix has anything like this real willingness to make changes (which implies being willing to make mistakes; if you insist that things be nearly perfect first, you're not really willing to make changes). In fact my perception is that this is one of the points of polarization in the modern Unix world.

(This is an elaboration on one of my tweets.)