🚀 go-pugleaf

In article <1993Jan9.025025.19137@husc3.harvard.edu> zeleny@husc10.harvard.edu (Mikhail Zeleny) writes:

   This is correct, but you could still restrict the GPL, and follow by
   licensing subsequent releases under the new version thereof, leaving
   the dreaded software hoarders with nought but obsolete "free" software.

Yes, and the US Government could redefine "public domain" as now meaning
"owned and licensable by Greenpeace", which would have far worse consequences,
but is more likely now that Al Gore is in the White House.

Even if the FSF was somehow taken over and the new "owners" released a new
version of the GPL that further restricted rights, several things would
happen:

1.  Significant legal challenges would be threatened (and probably
    succeed) regarding whether the new version of the GPL maintained
    the "spirit" of the previous version, as required in the GPL itself.

2.  The existing code, protected by the previous version of the GPL, would
    not be obsolete simply because its GPL was an older version; and,
    since the source code would still be freely copyable according to the
    GPL, people would have the same ability to continue to enhance
    the software as they do now.

3.  The FSF would lose most or all of its support, especially given how
    many people scream and moan about how FSF software is not "Truly Free"
    today (and somehow still have time to write truly free software?).

I cannot think of a better way to release my Fortran compiler than by
not only GPL-protected it, but signing copyright over to the FSF.  Sure,
bad things _might_ happen if the FSF mismanages things (they're no big
fans of Fortran, believe me :-), but the alternatives are generally
worse and more risky:

-  If I release the whole thing (source code and all) to public domain,
   then unquestionably I will end up having neighbors (in the Christian
   sense of the term :-) who ask me to help them fix or enhance their
   compiler derived even 99% from my code, and I won't be able to do so
   practically.  Further, I could lose everything I have to software-patent-
   infringement lawsuits, a danger I have no way to protect myself against.

-  If I simply GPL-protect the thing but don't sign copyright ownership
   over to someone like the FSF, I'm still open to patent-infringement
   lawsuits against which I can have no defense.

-  If I use other licensing terms that are more free than the GPL but not
   quite PD, I still have patent-infringement problems unless I can find an
   organization like the FSF that is willing to take the risk, which seems
   unlikely.  Meanwhile, some of the licenses I've seen considered "more
   free" than the GPL are unsatisfactory: those that restrict military use,
   distribution for commercial gain, use on Apple products (I just made that
   one up, actually :-), don't require source code to be available, and so
   on.

Releasing code via the GPL and/or the FSF isn't perfect.  But then, nothing
is.  People looking for perfection in the material, human realm will always
be disappointed unless they are easily misled.  Same for people expecting
Richard M. Stallman to be the ideal leader of the free-software
movement.  I fit none of these descriptions, and feel sorry for anyone
who fits any of them.

But, instead of bitching and moaning about rms, the FSF, or the GPL,
which I suppose I could do, I just keep writing code that, for all
practical and useful purposes, will be free.  I don't particularly care
that some people will restrict themselves such that they can't use
my code in the way I'd like them to and will permit them to.  And I
have no use for extremists who claim my 2.5+ years of volunteer effort
to write a free Fortran compiler isn't genuine because I don't release
it under _their_ terms (PD, or some other license agreement).  This is
the best way I've found so far (using both theoretical analysis and
practical experience) to do what I'm doing and have it benefit the
people most ready to be benefitted.  I'm not one to cast pearls before
swine, though I occasionally make mistakes in that direction when posting
to newsgroups, perhaps.  :-)

Ultimately, the GPL and the FSF way have advantages and disadvantages
that correspond pretty much to a radically new computer language or
operating system: it might seem ideal when one stays within the system,
but have (or appear to have) shortcomings when it comes to interfacing
to the outside world or, more specifically, being backwards compatible.

I've seen a .signature that said something like:

    "In response to the 5/2/2014 announcement by FooBar Computer Corp.
     of a new computer that fits in a shirt pocket, runs entirely on
     solar and thermal energy, and has the compute power and storage
     capacity roughly equivalent to a Connection Machine 10 or Cray
     Z-2, reporters quickly asked: 'Does it run MS-DOS programs?'"

The equivalent for the FSF might be:

    "In response to the announcement of a new software licensing scheme
     called the GPL that, if widely followed, would promote software reuse,
     increase innovation, cooperation, and useful competition, thus leading
     to better utilization of society's resources and improve the level of
     service provided to users of computers, reporters quickly asked:
     'Can I copy the GPL software and call it my own?' and 'Will an average
     computer software company be able to earn $1B using the GPL in 1Q92?'"

Not that these aren't valid questions, but it seems to me that people
who find that GPL too restrictive don't appreciate or consider the vision
of having software that you can _always_ fix or hire someone to fix because
you _always_ have access to the source code, not just because someone's
been nice enough to follow protocol and provide it (the pre-1975 standard
in some pockets of the industry).

But, then, some people think source code contains all the programmer's
knowledge of the problem (it doesn't, or else the problem is trivially
solved), so they somehow think there are moral reasons to withhold it
from people.  Fine.  My vision of where the computer industry will, or
could, go, includes technologies and capabilities far greater than what
we have today without necessarily requiring much better hardware (though
it would take much better advantage of better hardware than our present,
feeble conceptions), but is basically unachievable without vastly greater
cost _unless_ LPF and FSF concepts become more widely adopted.  In
particular, I believe software patents, look-and-feel copyright, and
even widespread release of binary images without corresponding source
code already unnecessarily hampers the industry today, and the degree
to which it does so will increase as computer-related technologies
(software, hardware, communications) increase.  (E.g. you'd be amazed
at how much we accept as "normal" in the way we use computers that
has come about partly because we _don't_ share source code; I'm more
aware of that since I'm one of the old fogies who was using computers
back when source code was much more ubiquitous.  It scares me to think
what kinds of ludicrous new approaches we'll have to invent and have
become "part of software engineering" to deal with look-and-feel
copyrights and software patents, but that's another issue.)

But that is just my vision, one I have cultivated and reality-checked for
over 20 years, and is worthless to anyone who is bent on whining about the
GPL and attacking those who, rather selflessly, help out the FSF in its
quest in making software freely copyable (not unnaturally restricted)
for everybody who wants freely copyable software (and many, apparently,
do not).  So I will not share my vision here.  After all, it's probably
pretty blurry anyway, and could turn out to be very wrong (though the
past 20 years suggest I've had pretty good vision so far).
--

James Craig Burley, Software Craftsperson    burley@gnu.ai.mit.edu
Member of the League for Programming Freedom (LPF) lpf@uunet.uu.net