🚀 go-pugleaf

In article <3NOV199113581633@minnie.me.udel.edu>, johnston@minnie.me.udel.edu (Bill Johnston) writes:
>In article <226@news.duke.edu>, magidj@cellbio.duke.edu (Jonathan Magid) writes...
>>we want people to originate *new* things, not spend their time 
>>innovating things that have already been done...

>This is exactly what GNU does not do.  It spends most of its 
>time reinventing programs that have been around for years.
>
>gawk, gcc, ghostscript ...

Well, I wouldn't include ghostscript in that list; there aren't that many
general-purpose Postscript interpreters around, and the other ones that
exist haven't "been around for years."  Also, I don't think ghostscript was
implemented by the Free Software Foundation; I think it was implemented by
someone else, and is being distributed under the GPL (just because someone
copies RMS's copyright notice format doesn't mean he works for the FSF).

>What is this but reinventing the wheel, or "innovating things that
>have already been done"?  Even the GNU OS, when completed, will 
>merely be "yet another PC Unix".  Free, but not innovative.

The problem they're trying to solve by reimplementing many existing tools
(and the OS in general) is that the existing ones don't meet their needs.
The things they want to allow people to innovate are frequently minor
enhancements or customizations to existing facilities.  Because source code
to most of the existing systems is either unavailable or prohibitively
expensive, users would be forced to start from scratch.  So, the FSF has
done much of the groundwork for them, by reimplementing these tools and
making the sources available.  Some people will fund the tools sufficient
as they are (especially since the FSF often does quite a bit of their own
innovation, either by improving the algorithms or adding features), while
others will be able to add their own enhancements (perhaps sending the
modifications back to the FSF if they're of general interest).

You mentioned gcc, and I think that's one of the best examples.  Suppose
you are a vendor of a computer system, and you need to implement a C
compiler for your system.  Some ways you can go about this are:

1) Start from scratch (well, maybe not that bad -- you could use lex and
yacc on some existing system);

2) pay a compiler house to write it for you;

3) license the source to an existing C compiler and modify it;

4) write a back-end for gcc.

(1) is quite a bit of work and requires lots of specialized expertise.  (2)
is common, but could be quite expensive.  (3) is likely to be very
expensive, and the work involved depends on the design of the existing
compiler (with luck they might let you take a peek before committing the
money, so you can shop around for a compiler with an easily-customized
back-end).  (4) is relatively straight-forward, and inexpensive.

The only complaint you might have with (4) is that you would have to make
the source to your compiler available and can't prohibit your customers
from passing it on to their friends.  But most of the code in the compiler
isn't even your own work, so what's the problem?

And the point of this example is that by implementing a customizable
compiler, the FSF has allowed you to innovate (i.e. write a new,
system-specific compiler back-end) rather than reinvent (i.e. write an
entire compiler).

Sure, they could have implemented all new tools and a completely new OS,
but what would be the point?  As crufty as it is, most people want Unix, so
the GNU OS and tools would be ignored if they were completely different,
even though source code would be available and they would be fully
copyable.

>By insisting that all GNU code improvements be 'CopyLefted', 
>the GNU source is off-limits to anyone who plans to write 
>commercial software.  Unless one buys the utopian vision that
>the software industry will give up the profit motive, one of 
>the main effects of the GNU restrictions will be to prevent
>innovators who happen to work for a company that copyrights 
>and sells software licensed in the usual way from using GNU 
>code as a a springboard for their next work.

But the GPL doesn't prevent people from asking for money for programming.
All it does is prevent them from being guaranteed a per-copy income.  I
believe RMS makes his living by charging for his time as a programmer (i.e.
he's a consultant).  Cygnus provides software support services for GNU
software.  In other words, these people believe that the software industry
should be viewed as a service industry, not a manufacturing industry.
There are many profitable service industries, so I don't see how their view
implies that the software industry must "give up the profit motive."  RMS
has been in the free software business for many years and he hasn't gone
broke yet; sure, he's not living in a mansion, either, but how many of us
are?

Also, once of the justifications often given for charging for software is
all the resources spent developing it.  If more software were just
incremental modifications of existing software this justification is less
powerful.  Writing a compiler is hard and takes a long time, and the
developer might feel justified asking for lots of money to make up for his
efforts; writing a back-end is much easier.

>This is the sad thing, because one of the most compelling arguments
>of the FSF is it would help programmers to avoid "wasting" the value
>of their programs by ensuring that others can build on the work.

But proprietary software also can't be built upon (unless you pay
exhorbitant licensing fees).  Public domain software can be built upon; RMS
doesn't believe in this because he doesn't want to make it easy for people
who would keep their enhancements proprietary.  In that respect, GNU
software isn't truly free; instead of a monetary cost, he asks his
customers to buy into his philosophy.

-- 
Barry Margolin, Thinking Machines Corp.

barmar@think.com
{uunet,harvard}!think!barmar