The Industry choice

[Paul Rubin]

Yes, apart from libraries and similar cases (frameworks etc), it's no
doubt rare for closed-source "end-user packages" to be sold with
licenses that include source and allow you to "do anything with it".

However, allowing customization (at least for internal use within the
customer organization), while rare, is far from unheard of.

There's no obstacle to doing that with GPL'd software either.

 

[Jeff Shannon]

You have the freedom of having to wash my car then. ;-)

A more accurate analogy would be, "You're free to borrow my car, but
if you do, you must wash it and refill the gas tank before you return it."

Note that the so-called 'viral' nature of GPL code only applies to
*modifications you make* to the GPL software. The *only* way in which
your code can be 'infected' by the GPL is if you copy GPL source.

Given the standard usage of closed-source software, you never even
have access to the source. If you use GPL software in the same way
that you use closed-source software, then the GPL cannot 'infect'
anything you do.

The 'infective' nature of the GPL *only* comes when you make use of
the *extra* privelidges that open source grants. So yes, those extra
privelidges come with a price (which is that you share what you've
done); but if you don't want to pay that price, you have the choice of
not using those privelidges. This does not, in any way, prevent you
from using GPL'ed software as a user.

(Problems may come if someone licenses a library under the GPL; that's
what the LGPL was invented for. But the issue here is not that the
GPL is bad, it's that the author used the wrong form of it.)

Personally, I'm not a big fan of the GPL. I'm much more likely to use
BSD-ish licenses than [L]GPL. But it still bugs me to see the GPL
misrepresented as some plot to steal the effort of hardworking
programmers -- it is, instead, an attempt to *encourage* hardworking
programmers to share in a public commons, by ensuring that what's
donated to the commons remains in the commons.

Jeff Shannon
Technician/Programmer
Credit International

 

[Bulba!]

Then you haven't read very many source code licenses, many (perhaps
most?) that state that if you've as much as looked at the code you're
not even allowed to write somethings similar twenty years down the line,
or anything that remotely resembles something similar.

I've read Novell license of internal development tools it provides
(which I reviewed for some purpose). This is I think relevant
part:

"Novell grants you a non-exclusive license to use the
Software free of charge if (a) you are [...] (b) you are
a contracted vendor (c) your use of the Software is for
the purpose of evaluating whether to purchase an ongoing
license to the Software.
[...]
You may not:
* permit other individuals to use the Software except
under the terms listed above;
* permit concurrent use of the Software;
* modify, translate, reverse engineer, decompile,
disassemble (except to the extent applicable laws
specifically prohibit such restriction), or create
derivative works based on the Software;
* copy the Software other than as specified above;
* rent, lease, grant a security interest in, or
otherwise transfer rights to the Software; or
* remove any proprietary notices or labels on the
Software.

Novell may have patents or pending patent applications,
trademarks, copyrights, or other intellectual property
rights covering the Software. You are not granted any
license to these patents, trademarks, copyrights, or other
intellectual property rights except as expressly provided
herein. Novell reserves all rights not expressly granted."

Other than that, the license had to do only with usual
stuff of disclaimers, different jurisdictions, export
controls, "US govt restricted rights", etc. Didn't find
there anything that forbids me to develop smth similar,
unless it's very well hidden in hooking into the technicalities
of specific intellecatual property laws.

I've also read similar IBM licenses -- granted, not very
carefully.

The thing that pissed off various bosses most strongly
in my impression was that the EULAs typically limited
or prohibited transferring the rights to use this thing,
e.g. to spin-offs or organizations cooperating with us.
It's bothersome in practice. None of that had anything
to do with source code or reverse-engineering or
developing similar products (if we wanted to develop
similar products, we would not be using this thing
in the first place, except for 'discovery' purposes).

I'm not saying licenses like you claim don't exist. Sure,
they may exist and they suck.

The point is, they have _limited impact_ and by
the very fact of their "exclusion" nature, this
aspect tends to repel users than attract them to
use this thing.

(Most do in fact
Now, Stallman might or might not want to achieve world domination, not
by sharks with lasers on their heads, but by aiming for all software to
be free software, but the GPL is actually a lot less ambitious than
that. All the GPL says is that: if you received a binary, the person who
provided you with it, must provide you with the source code that built
it. *All* the source code, not just what he happened to receive, on the
off chance that he's modified it.

Which I find again wrong: suppose this developer used GPL-ed
library A, developed patches B and C. He provided you with
the source code of publicly available library A and a patch
C, but he doesn't want to release patch B.

Now, I know that it would cost you the effort to recreate
patch B or maybe it wouldn't work without modifying
patch C. But that's an economic concern, which is orthogonal
to GPL, as GPL is (supposedly) about "free as in speech, not
free as in beer".

And as having the source code without
being able to modify it would be rather pointless, you're allowed to do
that too, it's a given. If you don't want to distribute binaries, that's
fine, and all of the GPL falls. The GPL doesn't *force* you to share
anything. It only says what must happen if you do.

True, not directly.

However, by attempting to create the context in which it's IMPRACTICAL
to use any non-GPLed software, it's attempting to achieve vendor
lock-in effect, and while in such situation you FORMALLY would not
have to give away, you PRACTICALLY would have to give away.

It's not there in license that you "have to give away whatever you
create". It's just attempting to create particular _economic_
context with those licenses, just like the licenses and practices
of a well-known vendor do, even though that is not spelled out
explicitly, obviously.

And I'm rather tired of the GPL's so called 'viral' nature. Look, if
you're using my code, you play by my rules, that's called copyright.

Of course. The point is, _what is specific content of those rules_.

Python's copyrighted, too:

http://www.python.org/2.3.2/license.html

And yes, we have to play by those rules, too. That obviously
doesn't mean that specific conditions are the same, and
those specific conditions are the crux of controversy.

If
you don't want to play by my rules, fine, don't use my code.

Do I have to point at who is also attempting to achieve this
particular context - "you don't like our licenses, don't use our
software"?

So far I'm
no better than Microsoft, or Sun (though that might change) or IBM for
that matter. With the GPL I'm actually not as bad as that, I'll even let
you look at the code, modify it, and distribute copies willy nilly
(though you I'm not forcing you to), in fact, I'll even *forbid* others
from taking that right away from you. If you use it, however, as a small
token of your appreciation, you'll have to also agree to not take the
same rights you had away from others.

I don't believe person A automatically has this sort of "right" of
reading/using whatever they want.

Finally, what *you* do with *your* code is of no concern to the GPL. As
long as you don't use *my* code you can do whatever you please. But, and
that's a big 'BUT', it really irks me when people release code under
e.g. the BSD (or as has happened to me in the past, public domain), and
then bitch and moan when I incorporate parts of it in *my* software and
release the whole under the GPL. As if that was somehow 'unfair'.

In a way, it is: you're taking liberties with their source and use it
in a way they did not _intend_ to. Just because this person doesn't
lock they house in hope other people will be considerate enough not
to rearrange the furniture in it just for fun...

Yes, their license _allows it_.

So what.

Look,
(and I'm obviously not saying this to the parent poster as he never
expressed any such sentiment, I'm just venting) that's what *you* wanted
when you released the code under that license. If you don't want me to
do that, then don't use those licenses, mkay.

Sure, if too many people do that, they will "lock" their house. And
only then I think we will be back on the way to the 17th century style
"secret science".

You're talking about taking the maximum liberties of agreements
and situations to achieve ideological goals. I claim that maybe it
would be nicer to base this thing on good-willed consensus rather
than paranoia and legal technicalities.

 

[Paul Rubin]

Note that the so-called 'viral' nature of GPL code only applies to
*modifications you make* to the GPL software.

Well, only under an unusually broad notion of "modification". The GPL
applies to any program incorporating GPL'd components, e.g. if I
distribute a Python compiler that incorporates some component from
GCC, then my entire Python compiler must be GPL'd even though the GCC
component is isolated inside the Python compiler and I wrote the rest
of the Python compiler myself. If I don't like this, I have an
obvious recourse, which is don't use GCC components in my Python
compiler.

The notion here is that the GCC components are attractive enough that
being able to use them provides an incentive to GPL my Python
compiler, which I might not do otherwise.

(Problems may come if someone licenses a library under the GPL; that's
what the LGPL was invented for. But the issue here is not that the
GPL is bad, it's that the author used the wrong form of it.)

The "problem" is not a problem except that in the case of some
libraries, simply being able to use a library module is often not
enough incentive to GPL a large application if the library module's
functionality is available some other way (including by
reimplemntation). If the library does something really unique and
difficult, there's more reason to GPL it instead of LGPL'ing it.

The 'infective' nature of the GPL *only* comes when you make use of
the *extra* privelidges that open source grants. So yes, those extra
privelidges come with a price (which is that you share what you've
done); but if you don't want to pay that price, you have the choice of
not using those privelidges. This does not, in any way, prevent you
from using GPL'ed software as a user.

Well put.

 

[Cameron Laird]

.
.
.

One last reflection -- I believe there are or used to be some programs
written by people no doubt of very good will, distributed with all
sources and often with no profit motive at all, which are NOT open
source because they include in the license some restrictive clause, such
as "no military use", "no use by organizations which perform testing of
cosmetics on animals", or something of that kind. These would be
examples of closed-source software which DO allow ALMOST any kind of use
-- any EXCEPT the specific one the authors dislike so intensely.

While most people may not think of such programs as "closed source",
they most definitely ARE: the definition of open source is very strict
about this aspect.


Alex

With my mathematical background, I'm consistent about calling
these "non-open" rather than "closed". I don't insist others
adopt my nomenclature ...

 

[Bulba!]

Well you are entitled to your opinion. But *my* opinion is that the GPL
attempts to ensure that if you re-use code by an author who so desires,
then redistribution of your code is only possible by making your own
extensions to it available on the same terms. This gives you a clear choice.

I agree with you. However, I don't see how your statement contradicts
mine.

To put it another way, it allows an author to specify that their code
can't be hijacked for proprietary purposes *in distributed programs*.

How can the source code that is _guaranteed to stay as public
availability_ be _hijacked_?

If it's hijacked, it's not available anymore.

Making derived work proprietary in no way implies that the base
work is publicly unavailable anymore.

I
will specifically point out that there is *nothing* in the GPL that
requires you to reveal the source of program you write but do not
distribute, even when such programs incorporate tons of GPL'd code.

Again, I don't see why that negates my thesis of vendor lock-in:
whatever software that uses GPLed code crosses inter-organizational
or inter-personal border, it has to be released with source.

Well that's way over-simplified. And if you mean Microsoft, *say*(
Microsoft.

Oh can't you take a little joke, why do we have to be so serious..

If my allusion was not funny, well, sorry.

The GPL folks are quite happy to have you "share" anything that *you*
create.

Oh absolutely, and I would be happy with them washing my car
for free. ;-)

Their simply-stated and elegantly-achieved intent is that you
don't "share" anything that *they* create except on the terms they have
required for their creations.

But their base work is available anyway, regardless of whatever
I do or don't do.

So, it seems to me, you are whining because the authors of GPL'd code
don't want you to release *their* code except under the GPL.

If that was limited to _primary_ effects, that would be
understandable. Which is why I'm rather fine with LGPL for
instance.

However, an openly stated goal is an indirect effect: achieving
the goal of "all the software in the world being free" (as in
their definition of freedom).

Which means that indirect, _economic_ result they hope to
achieve is precisely creating a practical context when this author
would have hard time to release his work under license other
than GPL.

Why do they call "library GPL" a "lesser" GPL, Steve, and
do not really like it? Is it not for the sake of this goal?

Watch this carefully: if what you claim was ALL they
care for, there would be no big difference for them between
LGPL and GPL. And yet for them it is quite a big deal.

What gives
*you* the right to dictate to them?

Conversely, what gives them the right to dictate the authors
of derived works of what they do with THEIR part of work?

How would you like it if Richard
Stallman insisted that you release your code under the GPL? Which, of
course, he doesn't.

Oh but he does - just indirectly. He's attempting to create such
context. GPL is a sort of wolf in a sheep's skin, while Stallman
pretends it's not really a wolf, and then preaches how wonderful
it will be when we will sit with millions of such sheep at the
table and vote what's for lunch.

Socialism is unpopular for many reasons, and many of them are indeed to
do with maintaining the separation between individuals and thereby
retaining the ability to treat them as separate economic units. But we
aren't going to change that by insisting on particular software
licenses. Realize this is a very small part of a very large debate.

Absolutely. I have discussed intellectual property rights issues with
friends to great lengths, not just regarding the software.

And that is their choice. They should realize, however, that some
licenses (including the more recent Python licenses) are cleared as
"GPL-compatible". I believe this means that if I receive software
licensed under a GPL-compatible license, I am at liberty to distribute
it under the GPL.

I suspect that this point is far too infrequently stressed.

I really don't find it very important: where the main battle
is, and where some vendors achieve domination and some
fail are precisely indirect economic effects of what they
do.

Not at all. It's written to be redistributed under specific terms, and
anyone who doesn't like those terms has the option of redeveloping the
functionality for themselves.

But they won't. And most of the time they never do. That is the very
point.

It's a subtle game: what you are _allowed_ to do intertwines with
practical situations and what you would _will choose_ to do
given how many factors influence your decisions.

You can't insist that people give you their intellectual property on
*your* terms.

God forbid! This certainly not what I meant, ever, and if
anybody suggests that, I have this rabbit right here that I
will release to get them.

That would be like insisting that the music industry bring
down the price of their clearly-overpriced products, or that the
Baltimore Orioles stop the concession stands from charging $4.50 for a
one-dollar beer. If you want a vote in such situations then your feet
are the appropriate instrument. Walk away, and stop whining .
Insisting will do you no good.

Absolutely.

However, what you present is very partial picture: there's much
more to it.

Since I'm taking issue with you, I will end by gently pointing out that
there's a substantial minority (? - my impression) of people who might
find your tag line (which I am sure is intended to be supportive of
Python and the c.l.py ethic, such as we might agree exists),
gender-biased and therefore just as unacceptable to them as the GPL
appears to be to you.

You haven't seen the episode of "Owl Stretching Time" by MP I see.
No worries, you just need a little re-education. ;-)

 

[Paul Rubin]

Making derived work proprietary in no way implies that the base
work is publicly unavailable anymore.

Since you want to be able to incorporate GPL code in your proprietary
products, and say there's no problem since the base work is still
available from the same places it was available from before, fairness
would say you shouldn't mind that people incorporate code from your
products into THEIR products, since your version is still available
from you.

Really, you're just a freeloader looking for handouts.

 

[Bulba!]

Yes, by all means let's just spout our opinions without any of that
inconvenient tedious empirical research which might invalidate them.

Err, but what did I do that got you visibly pissed off?

I certainly did not mean offending anyone. If I did smth
that did, I apologize, but honestly I didn't mean that. I
just expressed my opinion and cited some small bits of evidence,
which I think I'm entitled to.

The same is true of plasma-arc cutting for thicker steels, and I believe
it's still not possible to cut 3-inch stainless with a laser. But what's
your point?

<shrug> I was just explaining the issue for someone who could
wonder "why bother with cutting that with laser". The components
of those machines, even bigger ones, typically were not as thick
as 3 inches.

And you are using this example to try and argue that engineers are
better-educated than sales people?

Nope. The context was that behavior of companies tends to
be highly rational, optimized and not wasting resources. My
naturally individual experience was that it was oft not the case,
and that was the example.

Which was my point when explaining the clustering that
demonstrably happened: if the behavior of decisionmakers
is highly informed, rational and not really induced much by
risk avoidance as Alex claims, then the clusters are created
by "natural economic forces".

However, if the process is not that rational, then maybe
clusters are the correlation of "cover your ass" aspect
in managers' behavior all wanting to get their branch office
in yesterday in Tokyo, today in Beijing, and during
speculative craze in Russia in Moscow "because everybody
is doing that". Which observations of Paul Krugman on
"defective investors" seem to support.

Now, I'm very strongly opposed to saying that all that
somehow invalidates economics, including economics
of software, as _science_.

All I'm saying is that maybe this particular model is not
what some people think it is. This is the problem with
economics, people tend to get hot under the collar about
it for some reason and it's oft hard to debate that calmly.
Which personally I find a pity, because e.g. economics
of software is such an interesting subject..

Who sold this installation? Who
bought it?

I have no idea, as I were not a manager there and it
didn't really pertain my work.

Indeed not. Quite often the brown paper bag is a factor in purchases
like this. I wouldn't be at all surprised if somebody with a major input
to the decision-making process retired to a nice place in the country
shortly afterwards. You appear to be making the mistake of believing
that people will act in the larger interest, when sadly most individuals
tend to put their own interests first (some would go as far as to define
self-interest as the determinant of behavior).

But there is a subtler point here: most likely it was NOT in the
short-term personal interest to make this mistake (as I believe
corruption was not the case in this decision)!

After all, whoever responsible was still running the considerable risk
of getting fired. It is an example that precisely negates either
collective or individual, long-term or short-term, interest was
primary factor in this decision.

Some people are like that. I chose a long time ago to try not to work
with them whenever I could avoid it and, while that may have had
negative economic consequences I an convinced it has improved my quality
of life immensely. Of course, I have no proof for such an assertion.

Which in economic terms could mean that your "utility function"
is "modeled" in this particular way (well, strictly speaking utility
functions regard simple consumption), while most people tend
to misunderstand it as the idea that supposedly is "vulgar
consumption of as much stuff as possible is what makes people
happy" and they feel rightly repulsed from such an idiotic idea.
The trouble is, well-informed people do not to argue that, while
people tend to think economists actually do...

 

[Aahz]

Note that the so-called 'viral' nature of GPL code only applies to
*modifications you make* to the GPL software. The *only* way in which
your code can be 'infected' by the GPL is if you copy GPL source.

That's not true -- consider linking to a GPL library.

 

[Bulba!]

It's also noteworthy to consider that many times, waste happens not
because of corruption or self-interest, but simply because of errors
of judgement.

Precisely.

That is one of the main points I was trying to get across in
discussion with Alex. I have no reason to make conspiracy
theories that bribes were involved in that bad decision
at that German company. No, it _seemed_ like it was simple
mistake, because somebody responsible for this did not
research the issue in enough depth. And note that it
was definitely not in his personal interest, whoever that
was, a person or group of persons, as he/they risked getting
fired for that.

Humans being as we are, it's inevitable that over time,
some "obvious" important details will escape our attention, and the
resulting imperfect information will result in poor decisions. This
is a simple fact of human nature, and (ob-Python ) it's one of the
reasons that Python is designed as it is -- it makes a serious effort
to reduce the number of details that might escape detection.

I suspect it is one of the reasons why many people switch from
learning Perl to learning Python (at least I did - I simply
could not remember after a month or two what the hell
I concocted in this place in Perl program, it felt as if this
were somebody else's code).

(One should also consider that many business failures are a case of
simply having played the odds and lost. Many ventures depend on
outside events playing in a certain way; when by chance those events
happen, the decision-makers are called "bold and insightful", but if
things don't work out, they're called foolish or misguided.

Again, I agree with you - all that I can add is that it this is what
may be a rational element in the otherwise irrational decisionmaking
process - managers may get hit if it goes wrong, but not rewarded
if it goes right. Consider this:

"Moreover the fact that a CEO can command does not mean that other
employees will obey. Instructions can be given, but they need to be
obeyed enthusiastically by others for them to mean anything. CEOs have
tools to win the enthusiasm of their subordinates: the rhetoric of
shared accomplishment of action and vision; the carrots of promotions,
salary increases, and bonuses; the sticks of demotion and dismissal.
But even with these tools, managing a large bureaucratic organization
is a difficult task. And changing its direction away from that of mere
business-as-usual requires great skill and luck."

http://www.j-bradford-delong.net/Econ_Articles/Command_Corporations.html

 

[Terry Reedy]

Which I find again wrong: suppose this developer used GPL-ed
library A, developed patches B and C. He provided you with
the source code of publicly available library A and a patch
C, but he doesn't want to release patch B.

Then he does not have to. As I understand the GPL, as long as he does not
release (distribute) the patch in any form (in particular, binary), then
the GPL has no effect.

What strikes me as funny about GPL sniping is that many programmers,
including I am sure some of the snipers, sign Terms of Employment contracts
far more restrictive of their freedom than one could possibly accuse the
GPL of being. But I have seen little or no discussion of this (at least on
clp). In fact, I wonder if the GPL might be a substitute target.

Terry J. Reedy

 

[Bulba!]

Since you want to be able to incorporate GPL code in your proprietary
products,

Nope. That is not what I'm arguing. Really, I think you have
jumped to conclusion about that: I merely pointed out that
I don't like what I perceive as end effect of what GPL license
writers are attempting to achieve: vendor lock-in.

I think I stated that clearly.

and say there's no problem since the base work is still
available from the same places it was available from before, fairness
would say you shouldn't mind that people incorporate code from your
products into THEIR products, since your version is still available
from you.

I merely pointed out that previous poster's argument about
"hijacking" the OSS product: that it's just not possible
as long as this person is not in legal position to make _base_
work proprietary.

I think I stated clearly: base work is still available regardless
of whatever derived work creators do or don't do - esp. that
they tend to release only binaries, thus making it impossible
to create further derived works!

From the viewpoint of looking at availability of source code A,
it's completely irrelevant if those guys are fishmongers or
make derived work A' and redistribute only binary of A'. Not
a single line of publicly available source code appeared or
disappeared as the result of whatever they do. Amounts of
binaries - yes, that is affected. But not the source code.

Really, you're just a freeloader looking for handouts.

Rest assured this is not my motivation, esp. that I
attempt not to use the GPL-ed software whenever
I reasonably can (e.g. it's rather hard to abstain from
using gcc sometimes, as you oft have a hard time
compiling this damn thing with anything else -- see,
the beginnings of vendor lock-in appear). And I thought
I stated clearly that basically I have no problem with
LGPL - which requires distributing modifications
of the _base_ work, but not _your_ code.

Oh, and "freeloading" argument really doesn't make much
sense: since that software is available to EVERYONE,
its availability / unavailability in the economic sense it
is merely reducing / increasing costs equally for everyone
(ceteris paribus, assuming both vendor A and B find
that OSS product equally useful). I like to think of
OSS as a "tide that rises all boats".

 

[Bulba!]

There's no obstacle to doing that with GPL'd software either.

Which is absolutely true, but generally it's not the main _expected
effect_ that license writers aim to achieve..

 

[Paul Rubin]

Then he does not have to. As I understand the GPL, as long as he does not
release (distribute) the patch in any form (in particular, binary), then
the GPL has no effect.

I think the hypothesis is that the developer distributed the patched
library. The GPL then requires distributing source for all the
patches.

 

[Terry Reedy]

Absolutely not. Some people want to share under very specific conditions,
hence the proliferation of licenses in the open source world.

Indeed, Prof. Lessig at Standford University, I believe, recently designed
the Creative Commons license with a checklist of options with the intention
of allowing and thereby encouraging people to share under the specific
conditions they are willing to share under.
http://creativecommons.org/licenses/

Terry J. Reedy

 

[Aahz]

Nope. That is not what I'm arguing. Really, I think you have
jumped to conclusion about that: I merely pointed out that
I don't like what I perceive as end effect of what GPL license
writers are attempting to achieve: vendor lock-in.

I think I stated that clearly.

And my counter-argument is that I believe your perception is wrong. If
I agreed with your focus on lock-in, I'd say that what the GPL is trying
to lock in is a specific legal philosophy by subverting the existing
system.

 

[Bulba!]

A more accurate analogy would be, "You're free to borrow my car, but
if you do, you must wash it and refill the gas tank before you return it."

That analogy is an equivalent of LGPL. Not GPL. GPL in analogy would
require you to donate whatever you created thanks to studying the
construction of that car in the meantime. And yes, again, sure
that is what the borrower agreed to do, sure that NOT using it
at all does not result in such obligations, and again - that is not
the point.

Note that the so-called 'viral' nature of GPL code only applies to
*modifications you make* to the GPL software. The *only* way in which
your code can be 'infected' by the GPL is if you copy GPL source.
Given the standard usage of closed-source software, you never even
have access to the source.

Which means that standard closed-source software does not impose
itself on your software - except those detestable cases where
Stefan Axelsson pointed out, it prevents you from developing
smth similar if you agreed to such a pre-condition in EULA of this
thing.

It would appear that such a software attempts to economically
lock the user in using the only binary in the world that implements
this functionality; and FSF attempts to economically, indirectly
lock the developers - and indirectly users - in "being pressured
to give away" on the rationale of sharing being so good for
everyone.

Now, this may not be what they INTENDED - but from my
viewpoint it seems like that is the RESULT.

Not only I see this as unfair, but also as counter-effective
in getting more of people into both using and developing
software with publicly available source code ("free software"
guys tend to get hot under the collar when they hear
"open source").

Trying to bully people into this thing _for their own good_
tends to have the effect opposite to the intended. You
achieve more by showing positive attitude rather than via
conspiracy theories and paranoia. It is also this mostly
friendly and relaxed aspect of Python community that I
like so much.

Again, agreeing / not agreeing and resulting use / walking
away _are not the issue_. I don't see MS defended like "well
if you don't like whatever MS does, just don't use their
software, so shut up about whatever licenses MS actually
has and about whatever it does!".

If you use GPL software in the same way
that you use closed-source software, then the GPL cannot 'infect'
anything you do.

True, but that abstracts from source code issues, doesn't it?

The 'infective' nature of the GPL *only* comes when you make use of
the *extra* privelidges that open source grants.

Those extra privileges are the only way of _building_ large
software systems, isn't it? So I would define it as "normal".

Yes, closed-source is sort of "crippled" in this regard.

So yes, those extra
privelidges come with a price (which is that you share what you've
done); but if you don't want to pay that price, you have the choice of
not using those privelidges. This does not, in any way, prevent you
from using GPL'ed software as a user.

Obviously; but while what you wrote is true, it is not the crux of
the problem.

(Problems may come if someone licenses a library under the GPL; that's
what the LGPL was invented for. But the issue here is not that the
GPL is bad, it's that the author used the wrong form of it.)

Personally, I'm not a big fan of the GPL. I'm much more likely to use
BSD-ish licenses than [L]GPL.

Personally, I think that LGPL in abstract sense does make sense: if
you use and modify this thing, you should return back the _modified_
part - and this should apply regardless whether you keep it in private
or not, release in binary or in source to anybody.

However, it's definitely safer and since it also FEELS more benign,
BSD-like licenses are probably more productive in terms of motivating
people to cooperate, so I agree with you on that point.

But it still bugs me to see the GPL
misrepresented as some plot to steal the effort of hardworking
programmers -- it is, instead, an attempt to *encourage* hardworking
programmers to share in a public commons, by ensuring that what's
donated to the commons remains in the commons.

OK, a quick sanity check: does Python not remain "in the commons"
because some people use it in closed-source applications? I would
say that ALL of software released under GPL, LGPL or other free /
open source licenses remains in the commons.

All of the controversies seem to be about the derived works, don't
they?

 

[Bulba!]

[...]

That's remarkable, first time I see smth like this -
out of curiosity, could you say a word where was that?

Are you the same Bulba I know from alt.pl.comp.os.hacking?

No, but I like to see I have an evil twin out there.

 

[Paul Rubin]

And my counter-argument is that I believe your perception is wrong. If
I agreed with your focus on lock-in, I'd say that what the GPL is trying
to lock in is a specific legal philosophy by subverting the existing
system.

Bulba's perception is wrong in a different way too. The GPL tries to
encourage the enlargement of a public resource, namely a codebase
shareable by a worldwide community of users and developers, a cyber
equivalent of a public park whose facilities anyone can visit and use
but nobody can take away and exclude others from using. The idea of
referring to such a shared community resource as a "vendor" is just
bizarre.

 

[Jeff Shannon]

.... And note that it
was definitely not in his personal interest, whoever that
was, a person or group of persons, as he/they risked getting
fired for that.

This doesn't necessarily follow. The decision-maker in question may
have received a fat bonus for having found such a technically
excellent manufacturing process, and then moved into a different
position (or left the corporation altogether) before construction was
complete and the power-cost issue was noticed. That person may even
have *known* about the power-cost issue, and forged ahead anyhow due
to the likelihood of such a personal bonus, with the intention of no
longer being in a bag-holding position once the problem became general
knowledge.

Of course, this discussion highlights the biggest problem with
economics, or with any of the other "social sciences" -- there's
simply too many open variables to consider. One can't control for all
of them in experiments (what few experiments are practical in social
sciences, anyhow), and they make any anecdotal evidence hazy enough to
be suspect.

Jeff Shannon
Technician/Programmer
Credit International