[Tfug] GPL Worthless?

[Bexley Hall]

Hi Harry,

--- On Sat, 9/8/12, Harry McGregor <micros at osef.org> wrote:

> > Again, if the licensor is not defending his license, what value
> > does it have?  The linux kernel is, probably, the elephant in
> > the room -- more widely "copied" than GenericSoftwareXYZ *and*
> > with, potentially, the most muscle to defend same.
> >
> > I.e., guy writing a GPL'd program that plays TicTacToe is
> > probably NOT going to see widespread use, copying, etc.
> > Nor is he likely to have pockets deep enough to *do* anything
> > if someone violates his license terms (so, for these sorts
> > of development efforts, the GPL does nothing PRACTICAL except
> > stroke ego).
> >
> > When I suggest an FOSS approach to a client's problem, I am
> > *invariably* met with comments like:
> >    "No, I don't want to use Linux"
> >    "I don't want to have to give away my ideas"
> > etc.  Which then leads into a discussion of how FOSS does not
> > imply Linux (nor GPL).
> 
> Clients that can't get their head around the GPL won't trust
> anything FOSS, including BSD Licenses.

I'm not singling out BSD licenses except to illustrate something
"non-copylefted".  Note specifically the "e.g." in my comment:
   "This is, in essence, the big difference between GPL'd
   works and, e.g., BSD-ish licenses."

I've actually been reasonably successful in getting folks to
adopt "non-copylefted" sources in products.  A client who 
unconditionally balks at the FOSS idea then has a couple of 
alternatives:
- pay me (or someone) to develop the same functionality from scratch
- pay me (or someone) to research commercial offerings that might
  have similar functionality, pay the license fees for that/those
  products and hope the vendor(s) have designed quality products,
  are willing to support them at the level the client might need
  *and* will continue to make the product available in the future
  (I know of at least one case where the vendor wouldn't sell any
  more licenses for version X causing customer's product line to
  come to a premature EoL!)

When you put dollars and times (developing code, researching product
offerings, testing, etc. all "take time" -- all of which delay a
product's entry into the marketplace) on these approaches, it quickly
gets expensive for anything but a trivial "work".

OTOH, I've had to go the "from scratch" route far too often to
address NIH mentalities, etc.  <shrug>

> I know for a fact that IBM (whom I now work for) has put Billions of
> $$ into Linux development, and contributes back to the community
> extensively.

But, this goes to the issue I addressed regarding the express lane
at the grocery store:  it works only when folks embrace the concept
(like honest people stopping for traffic lights).

> Additionally ANY license has to be reviewed by Legal, be it
> GPL or even commercial, both for just installation and use, and
> for source code / project use.

Of course!  It's rare (on everything but "trivial" programs) for
a single license to apply to an entire "program" (i.e., including
all dependant libraries).

> For anyone to assume that a commercial license is "all that's needed", 
> is stupid and short sighted.   Heck, how many people actually read the 
> EULA with anything, even APIs and Widgets?
> 
> You can comply with the GPL and still use a Linux and GPL middle layer 
> in your application development without having to give away the farm 
> legally.  It's been done many many times.

This is a *lot* harder when you are designing hardware!  Sure, you
can bastardize your system design by moving "devices" to run *above*
the kernel -- in userland.  E.g., talk to them over a USB link,
network connection, etc.  But, that often makes them more expensive
to implement (e.g., needing their own processor) and/or significantly
complicates their interactions with the rest of the system.

E.g., imagine a custom touch panel and a custom keyboard each talking
to an application (without any kernel mods) via USB services.  Did the
user "touch" START before or after he typed the newline at the end
of "S T O P \n"?

> Is there accidental GPL violations (and even GPL violation
> on purpose), sure.   Those are found eventually, and dealt
> with.

I contend that I can comply with the GPL and still leave my successors
with something completely useless (in terms of being able to modify
that "source code" to evolve/derive it).  And, I believe these sorts
of possibilities are becoming increasingly more common and practical.

For example, I put FPGA's (Field Programmable Gate Arrays) in many
designs as a dense way of implementing "junk logic"... stuff that
would, otherwise, eat up lots of board space and money.  They are,
effectively, miniature circuit boards *in* chips.

Most of these (that I use) are "programmed" when power is applied
(and, possibly, reprogrammed during use!).  This involves pushing
a bunch of "data" into the device using a published protocol.
Thereafter, the device(s) behaves per the design embodied by that
"data".

This data is effectively an "object (code) file" produced by a
"hardware compiler" that takes a circuit description and maps
it into the correct set of data for that particular device.  A
different compiler (version) might produce a different data set.
A different targeted FPGA would most likely result in a different
data set, too!

The GPL doesn't require me to publish the "schematic" for the
hardware in this chip.  Even if I chose to, the tools that
generate the data from the "schematic" are often proprietary.
The *meaning* of the individual bits in the data set is almost
always a closely guarded trade secret by the chip manufacturer.

Now, imagine the data that I've pushed into that FPGA turns the
FPGA into a custom CPU (this is *20th* century technology).
Not only doesn't the GPL require me to disclose the design of
that CPU but it also doesn't require me to disclose the "code"
that I later *feed* to that device.  Just another "data set".
Or, several data sets.  Or, perhaps that CPU interacts with the
"real" CPU through a shared region of memory.  I.e., I've just
obfuscated what the code (which need not be annotated!) does.

[this is roughly comparable to releasing a binary-only version
of a driver -- because functionality can be hidden in the
actual "device" instead of exposed in the "driver"!]

Take this example a step further:  imagine that data set gets loaded
into the *main* processor (writable control store) -- i.e.,
rewriting its microcode (this is also 20th century technology).
Here's the source code for such an application:

const byte data[] = {
  <lots of numbers>
};

main() {
   load_wcs(&data[0]);
   main();   // grin
}

I've complied with the *letter* of the license -- but not the
*spirit*!  This is akin to a guy going through the express
checkout with three shopping carts -- each with exactly 10 items.
<frown>

> Don't get me wrong, there is a place for the BSD license along side
> many others, but a statement of "it's BSD, so it's clean" does
> not work, especially in a world of software patents.

I'm not claiming that a BSD license (or any non-copyleft license) is
"clean".  Rather, I'm commenting that the copyleft doesn't do what
it hopes to do UNLESS the licensee *opts* to be cooperative.  In
which case, he could just as easily be cooperative with a BSD-ish
license of his own choice!

[Paraphrasing the Subject line:  what's the copyleft *actually*
worth in *practical* terms?]

Personally, I use BSD-ish language because I *want* folks to
commercialize my designs and recognize they aren't likely going
to invest in the physical tooling to make boards, cases, manuals,
etc. if the next guy can just take their efforts and build on them.
It's one thing to take some piece of pure software and modify it.
Quite another when you have to invest in tooling, physical inventory,
etc. in order to pursue a design -- only to turn over all your
(software) efforts to your competitors as soon as you showcase your
product!

[It also lets me free up resources that would otherwise be wasted
in litigation]

Instead, let the next guy start from the same place *they* started,
make the same investment *they* made and *compete* for a better
end product!  He'll still benefit from being able to observe the
resulting products that he's competing against!  (without having to
come up with those ideas -- good OR bad -- himself!)

--don