Slashdot Mirror
Toward a Better Open Source License
With the success of GNU/ [?] Linux in the hacker community, and it's subsequent notice by the mainstream, there has been a rapid attempt by many businesses to "cash in" on the free (as in beer :() software phenomenon. This has led to the euphemization of free as "open source", and a plethora of so-called open source software licenses, that are almost, but not quite, as free as the GPL. With business being what it is, this should come as no surprise.
The trouble with many of these open source licenses is that they tend to be received with less than abundant enthusiasm by hackers -- the very people that business is counting on to debug, extend, and support, some latest software venture, all for free, while someone else makes a profit. If that isn't enough to discredit any semblance of inherent fairness, many of these licenses have been denounced as unfair by Richard Stallman, architect of the GPL. Many heed what he has to say.
The definition of fair in an exchange depends on both parties believing themselves better off with the exchange than without it. In theory, at least it is possible that while the above situation might be viewed as "fair" by somebody, it isn't very likely. So, the hacker community loses the opportunity to work with more software, and business loses in not having the support of this community. There must be a better way.
If the NPL were modified so that some limit was placed on what could be folded back with Netscape's proprietary code, this would be a start. But, who should decide what that limit is?
Clearly, anyone who comes up with an open source license can establish such a limit, even if only to say there is none. However, this does not make the license popular. Business will always want to "have it's cake and eat it too" and it should come as no surprise that present open source licenses suggest that the "cake" be pretty big. We can either wait for some company to come up with a fairer open source license, or we can respond with an alternative of our own, that need not be equal, but that many of us think is fair. To gain rapid acceptance, it would probably have to have Richard Stallman's approval (or at least be free of his disaproval), because of the respect he commands.
Here is one proposal, to put the ball back in the court of business, as it
were:
the Transitional General Public Licens (TGPL).
The TGPL is the same as the GPL, with two important exceptions:
- The originator may combine distributed derived works produced by others and released under TGPL with the originator's proprietary code and redistribute the result.
- The producer of a derived work may elect to distribute it under the TGPL, or the GPL, at their discretion.
Basically, this is the NPL in spirit, except the "in perpetuity" bit is cut off at a point decided by members of the community at large, in effect letting the originator have his pound of flesh, but not one drop of blood.
Obviously, an entire class of open source licenses can be thought of, that permit release of derived works either under the existing licence, or the GPL. The fairer the license, and the greater the value of the work released, the more likely it is that the originator will be granted his "edge" by grateful people who produce derived works. Furthermore, such community support encourages even more code to be released this way. That can only be a good thing.
Opinions are welcome, and openly solicited. Send them to rhollan@flashmail.com.
I like the idea of a transitional license that is more commerce-friendly, but still encourages people in the direction of using a true GPL distribution, but I think this particular concept is flawed.
If I grabbed the sources to a TGPL program and made some enhancements, I could decide whether to release this as TGPL or GPL, right? But if I went for the TGPL, _I_ wouldn't get any of the special benefits from this license, because those would go to the original company. This being so, I very much doubt that anyone would use it: we would all just put derived works under the GPL, which would essentially fork the project. This might work as long as the originating company was very active in development so that other people felt it was worth merging their changes back into the original source tree, but as soon as some other company made more substantial changes (which is exactly the situation that some licenses are trying to protect against), they would go for the GPL option. I think this would result in a lot of confusion, while simultaneously failing to protect the original company or feel truly free to the hacker community...
People are always complaining about the quantity of OpenSource licenses out there. Would it be possible for the OSI or someone to develop a single license with 5-10 "optional clauses" that an organization could add or remove when they release their software.
Presumably, in it's stripped-down state, the license would barely meet the Open Source Definition, and this would be the standard license that most companies would go with. People could then add clauses to make it similar to BSD, or the GPL if they are feeling very generous.
When an organization publishes the software, they can include the full license with it's clauses, but in press releases and such they can say "This code is licensed under the Flexible Public License, amended with Special Clause A, F, and H" or something like that.
I would think it could eliminate some of the bickering about licenses, some of the confusion about what one license offers that another doesn't, and also allow us to reduce the legal hassles involved in checking all these new licenses.
Is this even remotely feasible?
I doubt RMS will go for this one. TGPL source is _not_ free, it can be imprisoned at whim (forgive the anthropomorphism). Free software isn't about programmer freedom, which is obviously less under GPL than BSD.
Moreover, software companies will be fearful that the source will get GPL "contaminated" immediately. They like the NPL bargain "I'll let you have my code if you let me have yours". They don't see the critical importance of "Here's the code. It's free (speech)."
The GPL is very virulent. A softening is to allow the modifying coder an easy way (TGPL?) of granting a _second_ licence if s/he wishes back to the originator for the mods. The originator would then have to sift through unproprietarizable GPL'd mods, and proprietarizable TGPL mods. Not an easy task, but easier than asking permission much later.
-- Robert
The same reasons that make people and companies sign over ownership of changes to gcc to the FSF, and that make them contribute changes to software under the BSD license back under the same license, and that make them publish new modules for Mozilla under the MPL.
To avoid paying the stupidity tax. The stupidity tax is a term invented by the Mozilla team to describe the cost of having to constantly merge back changes from the mainline sources into your own project. The cost are very real, companies like HP pays significant amounts of money to Cygnus in order to have Cygnus merge their functionality back into the official product.
Of course, the stupidity tax only works when there are active development on the main code, so there _are_ changes to merge back. If a company have no intension of putting more effort into the code, they cannot rely on other people contributing their changes back to them.
A couple of possibilities, if you look at the price of software (assuming it is a manufactured product) then we would have components like
+------------------+----------+----------------
| Development cost | Know How | Marketing Hype |
+------------------+----------+----------------
Now from the OpenSource community, amortising the development cost over a wider base and eliminating the hype and know-how (ie stupidity tax for not understanding how it all hangs together) creates cheaper and more robust solutions. Would it be fair to say that all the community really wants is the source but not the hassles of marketing, distributing and supporting the product? If so, then value in excess of potential "lost profits" can be restored via:
In essense, this is looking at the GNU license and seeing what areas could be temporarily weakened without losing the principle of OpenSource. If people think hard enough, perhaps they can come up with other win-win scenarios. A trade is not a deal unless both sides can benefit.
LL
Redistribute under what licenses? If a patch is submitted without specifying whether it's for the GPL'd or TGPL'd fork, does it automatically go into the TGPL'd fork?
And I say "fork", because that's exactly what will happen the instant the code is released. Someone will grab it, rename it, put it under GPL, and isolate all further improvements to the GPL'd version. Which leads one to wonder why you wouldn't just create the fork in the first place by simply dual-licensing it.
Better would be a license that creates a publisher/author relationship, where copyright of any modifications is automatically assigned to the originator. Some sort of "good faith" enforcement clause would be needed to ensure that redistribution rights are not terminated. The FSF has this written into their charter. If they decided to revoke the GPL for every GNU package and turn it into closed-source commercialware, the rights of the consumer (redistributor) under the GPL would be upheld because the FSF would be acting in bad faith. Well, probably: "good faith" is always a judgement call. And they can play with the license as they please, within the boundaries of good faith: they OWN every line of code in official GNU software thanks to the copyright assignment agreements they require.
The charter of the KDE Free Qt foundation would be one place to look for a charter spelled out explicitly. If Troll ever goes out of business, Qt becomes BSD licensed.
But all this said, licenses are not computer programs. They are subject to interpretation, loopholes, and flat-out nullification in the case of bad faith, violation of existing law, invalidity under statutes of contract law, or just the amount of money one can spend on lawyers. If you do not trust the license issuer, you cannot ever really trust the license.
I'm not a lawyer, but I play one on Slashdot.
I've finally had it: until slashdot gets article moderation, I am not coming back.
The difference is that with the LGPL ANYBODY can link their program to your program/library.
/. is a great place to discuss (and hop, some shoe-waxing for Rob ;-)
With the TGPL this is the same as the GPL, that is only GPL compatible software can reuse/link to your code except that the originator can double license it to make it proprietary again.
I would like to have a TGPL license, this would help people to realease copyleft software. The scenario would be: You have a great software/library. You want to open it but you need to gain some money from it in order to live.
If you use the BSD/X license type you can make it proprietary but everybody else too, so if someone come with big bucks he can use your work, improve it quickly than you then outspace you technologically and you are stuck.
If you use the LGPL anybody can use/link to it and you will need to make money on support, which can be harder (because you're on quite the same level as other companies).
If you double license and use the GPL for the open license you probably will have some contribution for the GPL part which will become better than the closed part (because the claused part need to reimplement all the GPL contribution in a proprietary fashion) and the hassle to support both version can be very high (they risk to fork very quickly).
If you do like Aladdin (cf Ghostscript), you use a proprietary license and release the old version with the GPL you have the same risk (the GPL version overthrow yours).
BUT
If you use the TGPL license you have the same effect of the GPL (only GPL projects can use your code) but you can still relicense it under a proprietary license for your products without having the risk of the open version to cut your revenue because everyone use it. This is possible because the license allow you to incorporate the changes made by other into your product under your license. You then can release a proprietary version with all the features of the GPL + some feature you add to attract customers.
The problem with the TGPL as she stands is the second part: like other people said, if someone else can change the TGPL to the GPL for their derived work, then you risk to have the same problem you would have by using the GPL. I think this would be better if only the originator could switch to the real GPL.
The other problem is (like other pointed out) "who is the originator?". If I do a software under the TGPL but stop to develop after version 1.5 because all the feature i wanted are in and almost all bugs are out, will I still be the originator? If somebody else take the lead to the project and produce version 2.0 that is a 80% rewrit eof my crappy code, should I still be the originator? Shouldn't the new maintener be the new originator? Idem if somebody fork with my project.
I think the originator rule should apply while somebody is "actively" maintening a project. If they stop and somebody reactivate the project then they should find a ground to transmit the originator rights.
But this risk to shift the problem to the definition of actively. Am I still active if I contribute a small patch here and there while other are doing huge improvements?...
Ok, I'll stop here because I have to go but there are a lot of questions to talk about this subject, and
"The obvious mathematical breakthrough would be development of an easy way to factor large prime numbers." Bill Gates,
That last question is the entire point of this response. It seems to me that the businesses that would benefit the most from Opensource software is the large businesses. I make this statement from the evidence, look who is doing Open Source now: Corel, IBM, AOL(sorta), etc. Where is Ma and Pa's Software Company? Maybe small businesses have already been opening their software but the advantages seem to be exponentially less. One of the assumptions of the Open Source development model is widespread distribution. Surely Corel and IBM will get plenty of users but what about Ma and Pa's? Be? Opera?
Now for Part B of my argument. The biggest reason I use free software is that I no longer need to be spoon-fed by big businesses. It is nice. I can update when I want, check the progress of various software packages, and and recompile if I want. This is freedom people. I have grown tired waiting for Press Releases and exlusive Beta software to find out what is happening with the software I used to use in Windows Land. Now I can get a good idea by going to mailing list archives or web forums. Heck, I can even ask someone if I was really interested. But most of all, there is no need for buzzword features to get people to upgrade. Next buzzword: Open Source.
The effort the Open Source Movement has done to cater to big businesses really scares me. I still say we don't need to be spoon-fed by businesses.
--
Hmm.. Be gentle.. or not.. I'm delirious today.. ;)
At this point I'd like to extend a big thank you to ESR and OSI.. real swift going, guys.
Hackers.. not as stupid as the suits seem to think. I swear each new "open source" license feels like a direct insult. Makes me want to strangle the legal team who wrote it up and the people who set them loose on such an unholy task.
Ok, I'm sick of looking for quotes, so the rest of this is going to be off the top of my head (be afraid.. I just woke up..).. Do we really want to make "big business" all warm and fuzzy? It seems to me that if they want to survive in our little part of the software community, they need to find a way to do it themselves, without trying to compromise our integrity (screw us over with stupid licensing) or insult our intelligence (think we'll get a nice warm and fuzzy feeling because they used the words "open source").
Coining the term "open source" was entirely so it would not be threatening to businesses. Look where that "intelligent" decision got us.. I'm not so sure why everyone thinks we need to bend over backwards to get commercial support. We certainly don't need a whole lot of help producing quality products (a lot of GPL'ed alternatives blow the traditional software out of the water), nor do we need to do much of anything to have commercial support (I don't think we had to hold Red Hat by the hand to get them to participate.. do you?). The question being, I suppose.. what the hell do these companies who are scared to death of the GPL really have to offer us? And why are we trying to seduce them? Why does that even make sense to anyone? Someone care to explain this to me..?
Look, if you want to "play nice" with business, use a BSD- or X-style license (give up hard work to be popular if someone wants your work), or the LGPL (keep hard work free (speech) and still let it play with the "slaves"). Otherwise, why not stick to the GPL? I see no need to reinvent the wheel. If businesses want to make an "open" license that allows them to bundle stuff back into a proprietary ball, screw them. I've got better things to do than help someone make a buck without making some money myself. If they want to make it convertible to the GPL, guess what? I'm going to do so and they can just about kiss my ass.
Why are we constantly reinventing the wheel just to screw ourselves? Using the term "open source" instead of "free (speech)"? Trying to think of idiotic licenses that don't serve to fill any real niche in the world? Argh.. Brain.. hurts..
~ Kish
I think some of you are missing the point, either because you are fed up with the plethora of licenses out there that complicate things (when we spend more time worrying about licensing than coding, we really have lost our hackerdom), or because you see any compromise on the GPL as a weakening of free software. But the point of this proposal for the TGPL is, as I see it, to *discourage* big business from using all of that semi-free "Open Source" licensing BS that's getting thrown around these days (a la SCSL or MPL). The point is that it is clear that some companies don't want to give up control of their projects (Netscape & Mozilla, Sun & everything they release). This *could* be the community's response, saying effectively that we will play ball with companies using the TGPL, but that more restrictive supposed "Open Source" licenses will not be received with enthusiasm. Now, I'm not saying that the idea of the TGPL is thrilling, as it may discourage full-out embracing of the GPL, but it does offer big business an alternative to using some half-baked licensing scheme that they pay their lawyers a fortune to cook up. The great part about this would be that other GPL projects could nab code willy nilly from a TGPLed project (and simply GPLize it). On the whole, I like this idea despite the problems some have already mentioned about determining who is the originator, etc. Whether or not RMS would call it Free, I'd like to see some company pick up the TGPL instead of MPL, SCSL style licenses.
I don't know about the TGPL, but I want to comment on your questions about the originator. These are my own thoughts and do not apply that this is how the TGPL works.
I believe that if you start a project and produce TGPL code you should be the owner and be the only one to re-release it under GPL. The TGPL should stay intact until the owner relinquishes it. Even if you don't support it anymore, but you should have the option of transfering ownership to someone else. If you enhance the code (even rewrite most of it) it stays under the TGPL. If you are going to rewrite most of it, might as well rewrite the whole thing under your own license.
This is how I view GPL. If I want to continue a GPL product, I will write on top of it. If I don't feel I want the GPL license, then I will start from scratch. I find that the biggest complaints about the GPL is that it "restricts" from using with non-GPL licenses. I don't feel that this is a case. I only restricts those who did not create it. So it restricts those who want to profit off of someone elses work. The GPL is like a gift from programmers. But you cannot abuse that gift. If you use it and change it, you must also give it away (as in rights, not giving away free beer). If you use a GPL product and enhance it, give it to someone, you can charge for any more enhancements. But you can't restrict your customers from going to someone else, or doing it themselves. TGPL seems like it allows the creator to incorporate any changes that the customer has done (and released) or from anyone else.
I like this idea, because it still allows for a freedom of source, and it gives you away of being one up from it. So the community will support you as well as everyone else. But if you stop the support and don't transfer ownership, I don't see how that will be a problem because the product is still out.
Steven Rostedt
Steven Rostedt
-- Nevermind
I'm sorry, but I am unhappy seeing yet another 'open source' license turn up that undercuts what the GPL's about. It's this simple- the GPL is primarily, blinderedly, obsessively about causing the flow of information to continue and be unblockable. That's it! That is the primary goal.
The GPL is brilliant in its singleminded pursuit of this goal. There isn't a situation that couldn't be dealt with under the GPL. Every detail is perfectly realized in fulfilling this goal. For instance, there's no requirement to get consent of previous authors- so a piece of software, once GPLed, is guaranteed to live as long as it's needed, even if the original author wants to kill it! The doctrine that source follows binaries provides the opportunity to safely _use_ such software or privately develop it with no conditions on the development- and the use of 'distribution' is on a personal level that applies even to one person getting a GPLed software project from his boss at work- that person under the GPL _owns_ the software and has rights to redistribute under the GPL, any way he pleases so long as the source accompanies it. It's amazing that RMS saw all this- perhaps he didn't, perhaps it's simply the logical consequence of his passion for unhindered flow of information. The important thing is, it's here, it's available, and in fact Linux (at least big chunks of it) are licensed through the GPL, making Linux a form of information that cannot be effectively blocked or confined.
It's distressing but probably shouldn't be surprising to see these continued efforts- efforts that can only be to 'make a license that seems free/open but still allows the originator to block or withhold their information for the sake of profit'. Now, profit's dandy- wish I had more of it- lots of ways to get it, too. Freedom's dandy too- highflown words, pontificating, all very fun. However, the point at which the seeking of profit starts to undercut the safeguards of the GPL that keep information un-blockable- is the point at which my sympathy runs out.
The mere fact that this is granting extra benefits to the writer of the software isn't enough to impress me, either. Such a person is perfectly free to write proprietary software, nothing is stopping them, an entire legal edifice built around intellectual property is ready to defend their rights to do so.
People writing open source software ought to consider what they are writing it for. What is Linux for, when you think about it? What good is it? There are commercial Unices that are arguably as good technically, even better (depending on your particular requirements). What's so special about Linux?
Linux cannot be taken away.
Not even Linus can- if he threw a fit and decided never to share anything again, the license he chose, the GPL, would ensure that the work would continue, and would be available to all who wanted to get involved. No ifs, ands or buts about it. Even if Linus himself tried furiously to block any further development, along with the whole bunch of top-level maintainers. Linux _cannot_, legally, be taken away- that would be quite blatant contract breach, and nothing that is GPL can be withheld from you, no matter what anyone thinks, even if the original author gets nasty and wants to totally starve you of information.
Now, would that be the case if Linus was granted the special dispensation to release a proprietary version of Linux? If the authors and contributors all got to 'shut off' their code should they have a bad beard day? If that were so, Linux would be built upon sand- lots of pieces would exist on sufferance of the original authors, and you'd have to humor them.
We don't have to deal with that.
And I, for one, intend to continue releasing software under the GPL- and in so doing, I make a contribution that I can't un-make. I like it that way. Whether my work's good or bad, it is part of the great hoard of free information, the collection that will always be there to be used- on its own terms.
I'm never gonna use a GPL-variation that sets restrictions on the unimpeded flow of information. And that includes variations that give _me_ the ability to impede. I consider that wrong. If you're gonna write proprietary software, just do it, don't put up smokescreens.