[Someone]

If one of your employees accidentally copies even a single bit of GPL-licensed code into your privately licensed code or statically links against such code even once, and it gets ‘outside’ in any way, you legally have to release that version of your code under the GPL. Worse, the source code of all versions from _before_ that checkin automatically become GPL-licensed (because they contain code that, transitively, becomes GPL because it later was linked with GPL-licensed software)

Yes, that may not hold up in court if it is a tiny non-essential fragment or, if you revert to old code soon, etc. but that’s not the point; if you end up in court, you already lost.

With BSD-licensed code, that risk is way smaller. The worst you have to do is add a few (or quite a few thousand. Go check Setting/General/About/Legal for an example) attribution lines to the versions of your code that use the BSD-licensed code.

(Also, even if you choose to license your code under the GPL, you have to track licensing, as it isn’t legally possible to combine GPL2 and GPLv3 or APGL and GPLv3 licenses or any GPL with ApAchexlicensed code in a single binary. See https://www.gnu.org/licenses/license-list.en.html. If you want to troll GPL aficionados, license your code under GPLv1)

[belorn]

Thats incorrect on many points:

1: A single-bit is not copyrightable. True and false is not copyrightable. No one in history have ever been sued for a single bit. No one has ended up in court for a one-bit GPL code.

2: If it get "outside" accidentally, there is a direct remedy that do not include releasing anything. You stop redistributing the program. Practically all GPL related lawsuits started with the words "please stop infringing my work", and when that did't work, "Judge, please stop them from infringing my work". The only companies that have ever been "forced" to do anything is when the option is between a full stop in production and sale, or releasing source code. One such company chose to not cut revenue, not stop production, and instead gave us the code which the OpenWrt project was created on. I wouldn't call that "forced".

3: Code do not transform from being non-GPL to GPL. That is not how copyright work. Code is only under GPL if you explicitly release a piece of code under GPL. If you put MIT code and gpl code together, the MIT will still be MIT. The combined work must explicitly be under GPL to be compliant, but you can still use the MIT code in isolation under MIT. The MIT code do not transform into different licenses just because you combine it with other code. Only explicit action counts, and the worst thing that can happen from code getting ‘outside’ in untended ways is copyright infringement where you legally have to stop distributing code.

[lmm]

> If one of your employees accidentally copies even a single bit of GPL-licensed code into your privately licensed code or statically links against such code even once, and it gets ‘outside’ in any way, you legally have to release that version of your code under the GPL.

> With BSD-licensed code, that risk is way smaller. The worst you have to do is add a few (or quite a few thousand. Go check Setting/General/About/Legal for an example) attribution lines to the versions of your code that use the BSD-licensed code.

Accidentally copying GPL-licensed code into non-GPL-licensed code puts you in exactly the same legal position as accidentally copying BSD-licensed code without attribution: you are now, technically, violating copyright, and in theory liable for statutory damages of $150,000. You're never forced to release your code under GPL; the GPL copyright holder might insist that you either release your code under GPL or pay the $150,000, but equally the BSD copyright holder might insist that you pay the $150,000 - they're within their rights to do that.

In practice the author will most likely be willing to work with you to sort it out in either case.

> Worse, the source code of all versions from _before_ that checkin automatically become GPL-licensed (because they contain code that, transitively, becomes GPL because it later was linked with GPL-licensed software)

This is simply false.

[Fredej]

Where do you get the $150,000 figure from?

I would disagree that the situation is the same. The way to remedy the BSD situation is simple attribution. The way to remedy the GPL situation is release of the entire source code.

>> Worse, the source code of all versions from _before_ that checkin automatically become GPL-licensed (because they contain code that, transitively, becomes GPL because it later was linked with GPL-licensed software) >This is simply false.

Is it? If you are forced to release all your source under GPL any new release of that software will contain software released under GPL, even if the GPL specific changes are rolled back.

My interpretation is this: If you have two functions, A() and B() where A() is released under GPL. If you then release software where B() is defined as :

B(): ... A()

You now have a product which is a work derived from GPL code so you must release the source code for B(). Now you release B() under GPL. So you go back to the commit right before including A() and make a new branch with a new commit:

B(): ... C()

BUT! B() is now source code released under GPL so any changes to it must also be released under GPL.

How have I misunderstood?

[lmm]

> Where do you get the $150,000 figure from?

Years of conversation about this kind of stuff, I don't remember specifically. Looking it up wikipedia says $150,000 is the upper limit for wilful infringement, accidental infringement is lower, but that doesn't affect the argument.

> The way to remedy the BSD situation is simple attribution. The way to remedy the GPL situation is release of the entire source code.

The damages are statutory plus actual damages (almost certainly $0 for someone who doesn't make money off their software directly), not "what you would have done". You have the same options in either case: reach agreement with the person whose copyright you infringed, or go to court and pay the damages. So your worst-case liability is the same either way.

> BUT! B() is now source code released under GPL so any changes to it must also be released under GPL.

As you acknowledged in your reply, you still hold all the copyrights on B and can still release B under any terms you please.

[Someone]

(Aside: it doesn’t matter whether B calls A; linking with it is sufficient. In your example, B’s source became GPL licensed because it was linked with a publicly released A)

My logic was incorrect. I assumed that the exact same source code for now GPL licensed B from earlier revision revisions would have to be GPL licensed, too (and because of it, anything linked with that, linked with code linked with that, etc.).

However, licensing (unlike copyright) doesn’t work that way. Copyright owners can even release the exact same set of source code 7nder multiple licenses.

My conclusion still stands, though. Companies are right to worry about using GPL-licensed software.

[mavhc]

Or you can stop using it, and talk to the copyright holder of the GPL'd code and ask what they want.

Or if it's GPL v3 you have additional rights, fix it in 60 days etc.

http://www.softwarefreedom.org/resources/2008/compliance-gui... section 5.2