Subject: Re: the walls have ears
From: craig@jcb-sc.com
Date: 30 May 1999 00:03:28 -0000

>The real point, in my opinion, is "what free license is best when you
>*produce* software for a business".
>
>In this case the GPL is definitely the best option: the author doesn't
>keep exclusive rights (this is the ipothesis, as we are talking of
>FSB's), but at least he/she can deny third parties from stealing those
>rights. That's why I only use the GPL.

Be very careful of the use of the word "stealing", though I think
we all know how you mean it.  (At least, I take it to mean that,
after the exclusive rights have been offered to the community by
the programmer putting the code under some kind of free license
such as BSD, the GPL further ensures the author of the code has
the option of deciding whether, and exactly who, someone can
recreate those exclusive rights for themselves by packaging that
code in a product that is less available to the community, and thus
the author, than the original code.)

>On the other hand, I understand what Apache people is saying, but
>Apache is a powerful and reknown software/group. Maybe the advantages
>of apache being BSD are real ones.

They certainly are, IMO.

>However, most companies/groups/consultants
>developing free sw for a living can't afford the risk of being stolen.

The way I see it, viewed purely from the profit motive, the only real
risk is that the entity developing free software ends up getting effectively
locked out of (potential consulting/improvement revenues derived from)
some portion of the market that has been persuaded to use a product
derived from code written by that entity in the first place.

That's a real risk, but it's up to the entity to decide whether it
cares about this.  The original authors of the BSD'd code so widely
celebrated as having helped make billions of dollars for others
presumably have no problem with not being able to access, through their
consulting services modifying their own free software, pretty much
100% of that very (profitable) market without first having to convince
it to switch to products that either have *all* the source code
available, or derive from those authors' own proprietary creations.

(If they *do* have a problem with that, obviously they picked the
wrong license.  Same for any GPL authors who have a problem with
not being able to instantly spin off a proprietary version of
"their" product if it derives from code copyrighted by other entities,
such as patches, without getting agreement from those other entities
in the first place.)

>And sometimes to protect from this the software is made non-libre,
>even if available at no cost. But this is out of topic, as we are
>talking of FSB's.

Ah, but the attitudes and motivations of the "principals" of those
FSB's are *so* important in deciding what kind of license to use.

I believe it is largely because I *welcome* the idea that people
smarter, stronger, more bionic, just plain better than I, work on
and improve my g77 code without my initial approval (*not* in the
sense that I'm g77 project leader for the moment, but in the sense
that they can always fork), that I prefer the freedoms allowed me *and*
others by the GPL.

After all, no matter how wonderful their improvements, in theory,
at least, I can learn from them...if I can access the source.  The
GPL does the best job of guaranteeing this is possible, short of
requiring contracting with recipients of the code on an individual
basis (hardly a good method of distributing "free" software, but
maybe someday quite practical, given strong crypto and a ubiquitous
Internet...).

As it turns out, few people seem interested in modifying the g77
front end (partly because it's inscrutable, which I hope to solve
over the next couple of months).

So, putting aside the "minor" issue that the back end happens to be
gcc and thus under the GPL, I might as well have put g77 under the BSD
license, it probably wouldn't have mattered, except insofar as it
might have made inroads into markets unwilling to improve it under
the terms of the GPL -- markets that, by default, I would almost certainly
be locked out of, but to which I might have some possibility of gaining
access (and, obviously, even 1% probability of accessing such markets
is "better" than 100% probability of access non-existant ones; even
lack of access to my own source code within those markets doesn't
mean I can't earn income offering *user* assistance, based on the
hope that the products using my code aren't too different from ones
based *solely* on it).

Certainly, if I had decided from the *outset* that I was the best
(Fortran) compiler writer ever, that my code would be a Gift from
a Ghod of hacking, and that few people would be able to cope with
improving it while also running a proprietary-software business, I
might have preferred a BSD-style license (especially if getting
credit in ads for binary distributions was more important to me than
the ability of users of those distributions to modify my code as it
existed in their products).  Not only would end users not be able
to make good use of my source code in the proprietary products they
obtained, but even the *vendors* of those products would, from this
hypothetical viewpoint of my own skills vis-a-vis others, hardly be
able to add significant value to "my" program without, at some point,
having to hire me to help them.

In that case, I would probably be happier to have my source code get
wide public visibility, but would prefer to be able to derive, from
it *plus* whatever code I deemed worthy (such as the rare bug fix or
new feature added by someone else), proprietary distributions
that I could sell with typical restrictive (e.g. per-copy) licensing,
thus assuring myself a revenue stream (in the short run, anyway,
until someone figured out how to use my originally BSD'd code to
replace my product, but, with this hypothetical mind-set, I would
probably believe that unlikely, except insofar as it created a
market miniscule compared to the one I created for programs based
entirely on my free source code, to which I have 100% access).

There are plenty of other ways to look at licensing issue, but having
personally gone through a fairly longish "evolution" of thought along
these lines regarding how to do handle licensing issues for my own
(hypothetical) code, while also providing the kinds of freedoms I was
aware of wanting to help improve other peoples' code, over the past 20
years, it's clear to me that my main "leap of faith" was deciding that
there must be plenty of people out there who, merely by having my
source code available (*not* by my pre-approving them in some way)
in a *product* they were using, could do greater things to that code
than I might ever do.

(In case it isn't clear, I certainly have enough of an ego to believe
I *am* capable of at least helping architect a hugely fantastic,
earth-shattering, ground-breaking, software system, and have so
believed for over 20 years.  That I haven't done it yet is, of course,
irrelevant...though at least now I can tell myself it's only because
I haven't made enough my "vision" available to the masses so as to
enlist their help, one way or the other, implementing the "trivia".
So I'm not taking pot-shots at the BSD faithful above -- I'm really
describing the way at least *part* of my brain has always viewed
itself as a whole.  Other parts, of course, worry that anyone actually
*looking* at my code will conclude I'm barely adequate as a programmer.  :)

Once I made that "leap of faith", not only did the GPL seem "acceptable"
despite its "restrictions" (and, in that sense, it was competing only
against PD or whatever license I was willing to commit legal resources,
commensurate with what the FSF committed to creating the GPL, to create),
it made *all* sorts of issues that concerned me simply disappear.

(These issues were mainly technical.  They ranged from my theories
of Global Optimization, by which I mean a mythical program literally
reading all the code in a system like GNU/Linux or the Mac OS and
instantiating a version of it so thoroughly optimized that, as long
as you didn't change the source code, it ran rings around the originals,
which are instantiated/optimized piecemeal -- but which posed problems
for systems based on mutually "invisible", or hidden, source code,
which describes the Mac OS and most Windows systems -- all the way
to how to design a new PC-like system that provided a "way cool",
user-acceptable interface to all the hardware dongles proprietary
vendors would like to require their users to use, complete with my
plans for what the standard OS interface to them would look like, how
they'd be attached to the PC, etc.  Now when I think of these "heroic"
efforts to make proprietary software palatable in the faceof the
technical improvements I envision, and have envisioned for some time,
I chuckle, because the simple act of choosing the GPL for my software,
and especially for software I use, makes all those problems go away,
opening up much greater potential for those hypothetical improvements
actually being done sometime soon.  The remaining problems are, instead
of a SMOP, a SMOFR -- instead of a Small Matter of Programming, one
of Fund-Raising, or something like that.  I dunno.  Wife grilling
burgers; Brain switching modes.  Time to go.)

        tq vm, (burley)