Subject: Re: source access vs dynamism From: Erik Naggum <erik@naggum.no> Date: 1999/09/02 Newsgroups: comp.lang.lisp Message-ID: <3145299730732747@naggum.no> * Martin Cracauer | People seem to fear that the two latter options will produce too much | junk software. yes, but not directly. my argument has been that source access works against creating more dynamic and adaptable software, which is what people really need, but they settle for the best they can get in the static software world, which is source access. and for a while, source access will give people better software than the first dynamic software they can find will appear to be, especially in user interface gimmicks and in scale of deployment, which is why the software that we will wind up having after a few years will be less dynamic than what the dynamic world has today, and invent new and probably stupid ways to be dynamic along the way. it seems, however, that people argue against my position based on the belief that I fear that the free software that will be produced will be of low quality in its _own_ realm. that is not the issue for me at all, which I tried to communicate right up there in the Subject header. my problem is that the best quality static software will remain less dynamic than even low quality dynamic software is, and by encouraging source code access, the dynamic properties won't evolve in static software, because it will be easier to fix and recompile than to make the software more adaptable to begin with. | The first really free BSD derivate was 386BSD. The original author | misdeveloped it (simplification). If it was under license model 1, free | BSD systems would have died. this is not a certainty, but I concede it _is_ a possibility with not insignificant probability. the fear that projects will die seems greatly exaggerated to me, and leads people to rush to conclusions because they want to "save the source". (I'm reminded of environmentalists who don't manage to care about larger issues than some particular thing that gets a lot of attention.) | Commercial companies have shown a long history of producing inferiour, | not superiour versions of existing software as it develops. commercial companies are somewhat like human races -- they are much more diverse within the race than they are if you compare races to races. those who make claims about whole races are generally knocked down for it, but those who make broad and generalized claims about huge groups of people along other axes appear not even to notice. I'm opposed to broad generalizations along _any_ irrelevant axis. commercial companies have varied so much in what they have produced that I completely fail to see the value of such general statements. there is ample evidence to support the contradictory conclusion, too, but for some reason that evidence is disregarded. this smacks of an agenda that wants to hide relevant facts. | In general, software degenerates in that it is developed to be easier to | use in first place, but that serious users won't get the productivity | increase one should expect from really digging into a package. The | increasing instability of commercial software (can you say windows) is | just one example. Look at SPSS and its newer windows versions. but Microsoft profits greatly from the instability and the upgrade-mania. no other vendor in the software industry has exploited this property of evolving software in a purely destructive manner for anybody but itself. the sorry fact is that _anything_ that runs under Windows will rot in a few years because Microsoft wants to rake in billions of dollars from all the doofuses who think upgrading is going to solve all the problems that Microsoft created for them in the first place. witness how people are not at all understanding that Microsoft actively supports the spread of viruses and hostile software on their platform. all the evidence shows that Microsoft _actively_ creates new venues for virus producers to win and for Microsoft to _appear_ responsive to these "criminals" who cause Microsoft to earn lots and lots of money from people who fear that they will be lost at sea if they don't upgrade. the reason I don't use any Microsoft products is not that it wouldn't be cool to join the gang and exchange Word documents by e-mail and all that fun stuff, it's that I don't want to be held hostage by my own past decisions in the future. | I'm afraid that the advocates of the first license model in this group | are mislead by the fact that Lisp companies usually don't fall into | this trap, because they have no hope to make money from stupid users. and I think you're misled by the Microsoft horror story. as I have said many times, I think the current embracement of Open Source is a reaction to Microsoft's criminal conduct, and little else. I also think it will succeed in exposing what a fraudulent operation Microsoft really is, but the primary way to do that is to produce software that people can invest in and keep running for years and years. so far, Open Source suffers from the same problem that Microsoftish software does: it does not reach closure and stability. _novelty_ is what motivates people in that camp, too, not actual innovation. real innovative people leave good enough alone, while novelty-seekers don't. | That doesn't change the fact that the class of software packages that | suffer from this phaenomenon is so large that even most of us can't avoid | touching it. well, it doesn't have to be contagious just because it's rotten. you don't have to agree to its terms of existence to use it, either, but you should _definitely_ consider not upgrading. just slow their engine down and it will die and go away. don't renew licenses that you don't like. it's that simple. | Under the first license model, a tool I use might be taken away from me | (by dropping it or misdeveloping it). I only rely on tools that can't be | taken away from me. I learn rather slow and custumize highly, loosing a | tool would be a serious problem for me. so, _how_ did you lose it? don't you see that the reason it dies is that you have succumbed to the "upgrade or die" myth? it's a lie, pure and simple. _nothing_ dies if you don't upgrade. it just keeps working. you just don't need to upgrade quality software, but if you are on a support plan where you pay the same whether your software is upgraded or not, that only means the people who support you think they can do a better job if you do. this is very different form paying extra to upgrade. taking a look around me, I find that my accountant uses software he bought in 1985 on a computer he bought in 1992, and he has no plans to upgrade, because it does just what he needs it to do, and if he were to upgrade, it would only be a giant waste of time and money. my girlfriend still runs Windows 3.11 on an aging 486 at home because it does all she needs it do. my trusty old SPARCstation from 1993 still uses the very crisp and clear Sun M monitor, with production year 1987. it's basically a good keyboard and a good X server and display for the brand new Linux system I have, too, but that's immaterial. at my current client, we use old Pentium Pros from 1994 or whatever that used to be Novell Net servers as Lisp work horses, at exactly zero investment in hardware. we could do that because we use Linux on them, incidentally. the even older machine that runs Intel/Solaris is still in production use because it just hangs in there. now, I love new stuff, too, but not for its own sake. I don't buy used stuff, but I expect whatever I buy to last for a good number of years, and I treat it well so it does. software should be the same way: it's silly to have to upgrade the software because a particularly evil vendor has decided to make life hard for those who don't, only to notice that everything slows down just beyond the tolerance point, so you have to buy a new computer, too. _that_ is just plain crazy, but people believe in this "upgrade or die" myth, so they learn to live with it. | I'd like to add that I can understand your concerns when I look at the | casual users. In fact, they choose software on very weak measures and | there would be a real danger that people's bad choices push the worse of | two development branches and the better one dies. that's what happens. people choose the road with least immediate effort at every juncture. what's important, then, is being able to make the right and good choices become least-effort choices at a few junctions. some people refer to this as "killer apps", but I have no interest in the predatory world of such people. it's enough to change the habits of a few people at first. | But -and I think that's the reason why your opinions differ from mine- in | practice there are no developers who make bad branches of free software, | so the users can't choose the worse. the reason your opinion differs from mine is that we don't consider the same premises to begin with. I'm not primarily concerned with bad free software, I'm concerned that when people get source, they will think that's good enough that they won't try the even better dynamic software. a dictum of successful implementation of changes in a production facility is that the workers should be exposed to changes small enough that they will embrace them, but big enough that they can't go back to the old ways. failing to make them big enough will cause people to fall pray to habit. failing to make them small enough will cause protests and problems. if big enough is smaller than small enough, you have a permanent problem, but the key to successful implementation of changes is to widen the gap beforehand. I'll credit Microsoft with understanding this and making the most of it, but they're doing a bad job and they exploit it so that nobody but them _actually_ benefit from it. that can be changed, and it doesn't take that big a change to do it, just small enough that people will accept it, yet big enough that they won't ever turn back to the junk from Microsoft. I think truly dynamic software can fill that position with a few key tools and applications, but it must ride on the free software for now, and therefore it is vitally importnat that people don't see source as the answer to their _real_ problems, which is that software doesn't behave they way they want it to, but also can't express well enough that companies can respond to it. #:Erik -- save the children: just say NO to sex with pro-lifers