Subject: Re: source access vs dynamism
From: Erik Naggum <>
Date: 1999/09/02
Newsgroups: comp.lang.lisp
Message-ID: <>

* 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

  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.

  save the children: just say NO to sex with pro-lifers