Slashdot Mirror
Is Apache Or GPL Better For Open-Source Business?
mjasay writes "While the GPL powers as much as 77% of all SourceForge projects, Eric Raymond argues that the GPL is 'a confession of fear and weakness' that 'slows down open-source adoption' because of the fear and uncertainty the GPL provokes. Raymond's argument seems to be that if openness is the winning strategy, an argument Michael Tiemann advocates, wouldn't it make sense to use the most open license? Geir Magnusson of the Apache Software Foundation suggests that there are few 'pure' GPL-only open-source projects, as GPL-prone developers have to 'modify it in some way to get around the enforcement of Freedom(SM) in GPL so people can use the project.' But the real benefit of Apache-style licensing may not be for developers at all, and rather accrue to businesses hoping to drive adoption of their products: Apache licensing may encourage broader, deeper adoption than the GPL. The old GPL vs. BSD/Apache debate may not be about developer preferences so much as new business realities."
GPL or Apache doesn't really matters -- what matters is if you can make money. There essential matter is whether the software in question is a tool you use or the product you sell itself. If it's just a tool, the GPL makes sense, so you get contributions back. If it's your product itself, neither GPL nor Apache makes sense.
Be relentless!
Thats exactly what we need -- Another Licensing method. Just when all of the modifications to GPL weren't making enough sense just throw another one in the ringer!
"i lost my dignity on a slippery wiener"
The source availability provisions that come with distributing GPL software are a small pain for companies that want to make use of open source software, but that's about the biggest difference.
Anyway, over time, it will become obvious how big a concern the copyleft is to businesses.
Nerd rage is the funniest rage.
Without people like RMS fighting for the cause, I don't think the center would have moved so far towards FOSS today.
Supporting GPL in business is tougher, but it is also true that the benefits a company derives from open software are those it won't be able to reap in the future if the world turns back towards licenses which are less free.
But I don't mind LGPL.
If you are making money developing the software, the GPL with a dual liscence is a feature, not a bug:
"Hey Mr Customer, you can have it for free under this GPL thingy, or pay us $$$ and do whatever you want with it"
If you want to make money modifying the software, the GPL is a disaster.
Test your net with Netalyzr
If you're trying to get a protocol or "standard" of some kind as widely adopted as possible, then you should use a more permissive license (e.g. BSD, MIT, Apache). If you want people to embrace your product, yet then have to buy a license from you if they want to modify it in any proprietary way, you use the GPL.
It's basically a business question of whether you plan to make money DIRECTLY from the code (i.e. GPL), or whether you have ulterior motives for making money elsewhere (i.e. Apache). For examples of the latter, most of the largest permissive-licensed projects (Apache, Firefox, etc) are bankrolled by Microsoft competitors as a means to block Microsoft from having full monopoly power in a particular niche.
This really is a TIRED and boring flamewar. There simply is no "one license to rule them all". It depends on what you're trying to accomplish.
One thing the GPL offers that BSD-type licenses don't: protection from competitors. When a business releases it's code under a BSD-type license, it's competitors are free to take that code and expand upon it to make new products while keeping their code secret. As a business that means that you're always giving to your competitors but they don't have to give anything to you in return. The GPL, by contrast, allows your competitor to use your code as the basis for their enhanced product only if they give you their code in return. That means that whenever your competitor uses your code to gain a competitive advantage, you can grab his code in return and match him. You're never left holding the short end of the code-exchange stick. The only way a competitor can use your code without letting you use any improvements he makes is to not make any changes to your code at all. But if he's not making any changes or enhancements, you always have the first-mover advantage and he'll never be able to offer anything you aren't already offering. From a business standpoint, if you're going to open the source code at all the GPL provides assurance that the only way your competitors can hitch a free ride is if they accept always being in second place behind you when it comes to new features.
That's assuming you can open the code in the first place. For code that's not critical to your business it's an easy answer. If the code is critical to your business, the first question you need to ask is whether or not you can open it to the world in the first place. Opening it means the entire world can see the exact thing that sets your business apart from others in that case, OTOH it also means the entire world can offer improvements and that means you're effectively getting a development department not even giants like IBM and Microsoft can afford for free. Keeping it closed means you can avoid revealing the keys to your success, OTOH it also means there's huge amounts of useful software out there that you can't use and will have to pay to get (either in cash to buy commercial versions or in time to duplicate the functionality). I can't say whether the trade-off's worth it for any particular business or not, but as a businessman you'd better be asking that question and getting a solid, well-grounded answer to it.
Yes.
Error: password can't contain reverse spelling of ancient Chinese emperor
GPL is a hindrance.
Whenever we use anything that is open source the first thing is to ensure it is not GPL'd. If it is GPL'd we find another solution or write our own.
Whenever we release any source we put the most permissive license on it we can - which translates to "You can do whatever you want with this EXCEPT put a GPL style licence on it" because we want anyone that uses anything we choose to give away to be free to make money with it or give it away and have to do nothing in return unless they want to - that is more freedom than the GPL gives you.
Ahem hard work by both ASF and FSF made GPL3 legally equal to ASF2 so its kind of a mute point.. I think there are more important valid points to debate about
Fred Grott(aka shareme) http://mobilebytes.wordpress.com
My example is the number of packages in the Debian Free repository. There are, no doubt, quite a few licenses among those packages, but they meet Debian's high standards for Free software.
Businesses will always do their best to capture all of the value of the work of others. There are no end to schemes meant to capture the value of GPL software and prevent others from using them. Tivo's kernel hack come to mind....
http://www.maxineudall.com/2010/02/should-economists-be-sued-for-malpractice.html
And there you hit the nail on the head. If the software is the means to some other end, then yes, the GPL or some derivative would seem to make the most sense, in order to ensure that any improvements someone else might come up with are propagated back into the main branch. I would wager that this holds true for most FOSS projects -- and the SourceForge figures of 70% of projects using the GPL would seem to back this up.
But if, as you note, the software is the end in itself, if it is the product one is trying to sell, then proprietary is really the only way to go, simply from the perspective of locking others out.
And therein lies the crux of the conflict -- those keenest to use any piece of software are also keenest to see it spread and improve as quickly and efficiently as possible, while those trying to sell any piece of software are less interested in improvements than in maintaining exclusive control. These would appear to be orthogonal goals. The alternate model of giving the software away for free and charging for service instead adds an interesting wrinkle to the equation.
Cheers,
"What in the name of Fats Waller is that?"
"A four-foot prune."
How does having the ability to close down the product a better freedom?
Actually with the GPL, you can dual license since it's your own software and thus have a free GPL version and then a privately extended version if that is what you business is looking to do...
With BSD, well, all your concurrent company can do the same and compete in the proprietary version with you, how is that helping you?
Raymond argues that GPL is bad because it's an uncertain license... what?
If Cisco can't read that it has to distribute source code, well, that is a shame with all their lawyers.
Anyone else KNOW what they have to do. So there is no ambiguity there!
Same goes for Google's Android going with the Apache license...
Basically in that super proprietary cell phone world, they are more than happy to have it under a BSD like license.
Now every company can build an OS together and all close them on their side leaving you, the user, with nothing out of that openness except the base system which might well be unusable.
See how MacOS X free part is free/useful compared to the full product? Haha! ...
So they save on development cost, like they would have with the GPL but remove the idea that they want to guarantee that this investment will be guaranteed in the future.
It's like a trap to win the cellphone OS race and then, when it's too late and they have such an insurmountable market share, they close it and we go back to business as usual...
As a user i can't trust that, I'll go with Maemo, OpenMoko or anything that has as much GPL as possible if i have a choice!
(which right now I don't really have, but this year is going to be interesting! I hope ...)
Depends what business adoption means. If I would want distributors like Microsoft and Apple to adopt my software, I clearly would not use GPL. But if I want to stay involved (i.e. have access to their modifications), using the GPL is definitely recommended. Maybe something like the Apache license (or even BSD without patent clause) is globally the winning strategy. But that's a small comfort for the individual developer getting sidelined.
...it'd be better for business, at least in the sense that more people would find commercial opportunities with it. But would that code be open source in the first place, were it not for the GPL? I doubt it. Most companies don't want to give away source competitors could put directly in their proprietary products. Give away GPL code? To use it means the competitors would have to open source their application, turning them into a service and support company rather than product sales, where you'll beat them on accrued skill and experience. I'd also say that a lot more individual contributors subscribe to "share and share alike" than "share and kthxbye". My point is that it's not like you got two equal options, either you use GPL code or you have to write it yourself because there is no such Apache code. Would be nice if there were, but then I'd like a pony too.
Live today, because you never know what tomorrow brings
in that the Apache license dealt with patents (which, being outside copying is still able to ensure you can never use the original BSD licensed code if someone takes a patent on it) and therefore was a better BSD than the BSD license.
This is of course a centuries old debate. GPL projects have the patience, confidence, and self-respect to wait for the right business to come along, one that will make a real commitment to a long-term relationship and honour its responsibilities. Only then does it get the source.
On the other hand you've got the projects with the much more liberal BSD or Apache licenses, projects so desperate for attention that they'll jump into bed with any business, and give up their source at the drop of a hat, not caring if it gets mistreated. Sure they can be convenient if you need some quick and dirty code, but mother always warned me about projects like that.
It isn't
"If you want to make money modifying the software, the GPL is a disaster."
It's if you want to make money modifying SOMEONE ELSE'S code, the GPL is a disaster.
If it's your own code, you can add non-GPL bits to your code and still make monopoly rent.
If it contains someone else's code under GPL, you can still make money from the modifications, but you won't make a monopoly rent from it.
Eric is basically right. I've been burned in the past, so I now pay attention to the license an application uses (something you should get into the habit of doing).
Here is my decision tree for deciding to use an application licensed under any FOSS license:
1) If I plan to modify the application in any way, or use it as a library, it has to be under a BSD derived license. This means BSD, MIT, Apache, MSPL, Perl's artistic license, or anything similar. GPL, or any "viral" license is out... I dont touch GPL code anymore (actually, this is a lie, see below).
1.1) There are exceptions to the "used as a library" rule. If everybody else is using said library in their application (eg: libmysql), nobody is gonna try to GPL-ize my whole application. And if they do go after me, it will only be because I'm so successful that I become a target for such nonsense. If your library is nothing more than a CPAN module and it is GPL, I can't use it, sorry.
2) If I don't plan to modify the application for use in my project, the license becomes less important. In these cases, I look at other factors such as how active the project is. I don't like depending on projects that haven't been touched since 2005.
3) If your application or code will become a non-linked dependency of my application (for example, a GPL'd version control system), I don't really care what the license is. Since it isn't linked into my application, I won't get "infected". In fact, I might even contribute to your GPL project provided my contributions are independent works and don't come out of my own "toolkit" so-to-speak.
4) If you require me to assign copyright to you before I can contribute, you are a scam and can piss up a rope. Granted, many of the big-boys require this (most GNU stuff, Firefox(?), MySQL) and so I might be willing to cave in an contribute anyway provide what I'm contributing is an important bugfix and doesn't erode ownership my personal toolkit (i.e. the good stuff). The scam guys are companies who want ownership so they can cook up dual license schemes and profit from your work (MySQL). Scammers can pay for their own bugfixes...
Bottom line, I won't touch GPL for anything that might make my mainline code become a derivative work and force it all to become GPL'd. BSD'sh licenses cannot do this to my mainline code, so I can use their stuff and contribute anything I think they will find useful. GPL doesn't let me cherry pick useful stuff out of my code, so they miss out on some pretty cool things. Since I dont like leeching from GPL stuff (using it, but having no way to give back), I just avoid it instead.
In other words, if you GPL your project, $SUPER_BIG_COMPANY can't lift your code and make $MILLIONS$ but only at a heavy cost--the pool of people who are able to work on your project becomes much, much smaller. BSD-style licenses are attractive to business precisely because business knows they can contribute changes without getting into trouble. If I use a BSD anything, I know that I have the option to deeply embed the code into my application, still be able to contribute back any changes, and retain control over my intellectual property. GPL reduces control over my IP and thus I can only depend on it in the loosest way possible. The second I want to make any contributions, depending on how I used the GPL code, my entire portfolio might be in legal jeopardy. Not cool.
PS: IANAL
The difference between the GPLv2 and BSD is simple:
So in the end, the choice is whether forking or merging is more important to you. Forking may mean more people can use your code. However others would argue the merging means more people can benefit from the collective contributions.
I think we have to ask: What has the GPL done for us, or at least probably done for us?
Starting a decade ago several very large corporations poured significant resources into Linux development, and were compelled to keep their contributions open-licensed and essentially free (as in beer).
Do we think that would have been the case if Linux had been Apache or BSD-licensed, or would we instead see a division into deluxe IBMLinux (that works on multi-processors and new chips and 64-bit) and open Linux that scrapes along on simple 486 hardware.
Where are we going and why are we in a handbasket?
not only is Eric Raymond wierd, slashdot.org seems to be having a cookie problem...
Politics is Treachery, Religion is Brainwashing
i.e. you want to have your cake and eat it too. i.e. dual licenses schemes like MySQL's. i.e. you want to sell your GPL code.
For you "owner" of the code, yeah--especially if you are extra weasely and require copyright assignment. For contributors, it is a scam. Why the hell should I contribute to your dual licensed garbage so you can turn around and profit from my work? I never understood why such companies aren't hassled more about this. It is really a great scam--you get a bunch of people contributing to your work for free and you get to sell it all. Course, I guess the same holds true for most things on the internet--flickr doesn't take pictures, its users do and flickr profits from that. Slashdot doesn't have a script to write comments, we write them and they profit from that. So I might be wrong on this... but the dual-license guys seem way more blatant, probably because I get a lot of satisfaction posting here, but dont really get much satisfaction contributing to some faceless corporations open source project.
A sucky one though. I doubt many programmers on this board want to be in a position that the work they produce for a company is essentially worthless and the way to move up is through the tech support department. I also doubt customers would benefit either since giving away the software and charging for support creates an incentive to make shoddy software that requires a lot of hand-holding.
I opened this article and was somehow in a different users account; I refreshed several times, and got at least a half dozen user accounts other than my own.
Anyone else getting logins to random accounts?
And now let me rant about how Slashdot gets worse by the day. Not only do I have to log back in to Slashdot repeatedly when browsing (because I'm "behind a corporate firewall")(imagine!!) but now I find myself browsing this particular topic as user "1779"! Sorry, 1779, I'll try not to muck up your view settings.
It will be interesting to see what Slashdot user posts this, now won't it? Will it be me? 1779? SomeOtherRandomUserAccount? How F&CKING hard is it to keep track of my log in name between subjects? Rtards.
Thank you. I feel better. Go on about your business.
BSD/Apache makes the most sense if you plan to sell out your principals for a few dollars. GPL makes the most sense if you have scruples.
How much for your mother?
Actually with the GPL, you can dual license since it's your own software and thus have a free GPL version and then a privately extended version if that is what you business is looking to do..
Then that would be a derivative work and a violation of the GPL if you did that.
Who is this Eric Raymond really ?
so if it were closed source, you wouldn't be able to use the code either.
And you ALWAYS have the choice of writing your own. Or do you think your company should be allowed to "steal" the work of others?
From my understanding, if you own all the copyright you have a right to republish under different terms and extend all you want, which doesn't remove the original GPL source code from circulation of course.
Like QT did and i think MySQL and probably others.
Here's an idea.
Let's take the anti-capitalist hippie and the gun-loving greaseball, lock 'em in a room with five sticks, and see who comes out in the end.
And just to be sure of things, we'll use really good locks on the door.
I'll be happy to consider any other way of getting these idiots out of the way, but the time for zealotry is over--it's time for the various subfactions of the cult of Linux/Gnu/OSS/FOSS to grow up and put their efforts towards mature products, instead of arguing over details that scare potential users away.
"People who do stupid things with hazardous materials often die." -- Jim Davidson on alt.folklore.urban
From the FAQ: Why is someone else's User Name appearing on my User Page's Menu? ;) that you have visited. This is useful when you want to hop around between your user info, and someone else's: to compare friends and foes for example. Your account has not been hacked, this is totally by design.
This is not a bug. This is a feature! That name is the last user page (besides your own
It's a badly implemented feature. You don't really have someone else's identity, it just looks that way. Maybe. It may have a bug that lets you use someone else's mod points. I just got a "Moderate" button from someone else's account.
I've gotten 8 other accounts, with their preferences and hidden emails, as well as mod points.
It only stated happening today, too.
he forgot "doubt". Jeez, you'd really think he'd know what he was spreading.
It would be only if the work includes code that you don't have copyright to. If it's your product, this very well may not be the case.
I gather Slashdot doesn't make a lot from us writing comments. They make money from the advertisements we see while browsing. Comments are just slashdot's way of fostering a community and increasing page counts.
You can't legislate goodness. Let each to his own destiny, by will of his freely made choices.
As much as I appreciate Eric's contributions to open source (his early writings helped get me interested in writing open source), and our shared interest in shooting guns -grin-, I prefer Bruce Peren's approach (as I wrote about recently http://markwatson.com/blog/2009/02/bruce-pernes-on-gnu-affero-general.html).
I think that a combination of AGPL, a less restrictive license like MIT or Apache 2, and perhaps something like the LGPL cover most needs, and the fewer licenses the better. The point of the article is that GPL is not good for business, raising VC for startups, etc. Perhaps true, but I still believe in the more restrictive (for developers) forced sharing of the AGPL is better for a world where software infrastructure is just about free because a very large number of people and companies supply resources for coding, bug tracking, and documentation.
I would rather do work for customers that involves adding functionality to an already great open source project, and I would prefer that improvements be folded back into infrastructure that everyone can share.
BTW, I disagree with Stallman's and the FSF's take on cloud computing as long as:
1. you have access to the software that you are running
2. you can easily copy your own data
3. you can easily migrate to your own servers or other hosts
I think that both EC2 and App Engine meet these requirements.
If you look at big companies like IBM who have really embraced OSS, they have done so precisely because of the GPL. The GPL is really the only license that makes a lot of business sense. The GPL has two major advantages over other licenses. First since you own the copyright you can dual license the code as proprietary and GPL if you wish, while making sure that code can continue to be developed by a community and protected from exploitation---the only caveat here being that you have to make sure copyrights are always assigned to you, something that many projects do. The second major advantage is that no company can use your code against you in a competitive manner. The playing field is completely level. If improving your code helps a competitor, it also helps you. Given all this, if I was a commercial company, wanted to have my projects be open source, and I owned all the copyrights, then it's a no brainer. the GPL is the only way to go. It seems like the only time people complain about the GPL is when they don't happen to have a natural copyright to the code and for some reason feel some sense of entitlement to code (if it's open source I should be able to use it how I want, dang it) just because it's OSS. It's very bizarre.
Frankly I'm surprised to hear of such blatant FUD coming from someone like ESR. I think the solution to FUD is to be a bit more vocal about defending what the GPL is actually about and how it protects users, developers, *and* commercial corporations. It's not public domain software. It's source code just like source code from any other source. If it's not yours and you don't want to abide by the license, buy rights to the code or stop complaining.
I think you're missing his point. If you make food, and you have a customer management system that is a means towards the end of staying in touch with those you supply food to, then the software is a means to an end, and the GPL makes sense.
The dual licensing schemes like MySQL don't fit this descriptor. The software is not a means to an end for those guys, it's an end in itself. And yeah, it's a scam. You want a great example of that scam in operation, look into the history behind Project Mayo, DivX Networks and XviD. A few guys took a boatload of peoples contributions and then sold em out, now they basically get a tax for every video player in existence.
-1 Uncomfortable Truth
It doesn't matter if GPL is the ideal license structure for open source development. There is a huge amount of "GPLv2 or later" code out there. By licensing my software with a compatible license, I can copy bits of that into my creation without having to rewrite it. When one writes a little utility that doesn't link to anything and when one writes something where it is good practice to rewrite any external code for auditability, like OpenSSH, one is free to choose whatever license one wants. But when building something substantial quickly GPL wins just on the easy incorporation of external code argument alone.
I do realize this same argument could have been made about closed source ten years ago, when you could license helper code easily and cheaply for your closed source project but no open source equivalent existed. But this really means the question is not whether an Apache license is superior to a GPL one, but is it superior enough to go through the enormous effort to redevelop or relicense all that code which exists in the GPL ecosystem now? The people who have answered yes to that question are by and large in the BSD camp. I have great respect for them, but I have to admit that their effort appears more quixotic to me now than it did just a few years ago. Throwing the Apache license in there is silly, it's an outlier and there are good reasons to think that if the project were started today it would be GPL licensed. If you have philosophical objections to forcing sharing either explicitly place the code into the public domain or use a modern variant of the BSD license; using fewer licenses reduces the sharing friction.
As to the value of the GPL's forced sharing, I've also had the experience of having numerous businesses based on software I had a large part in writing. All of them placed their enhancements online, one explicitly contributed back with patches. I believe the one that explicitly contributed back would have done so even if a sharing was not forced, and very little of the code written by the other companies made it back into the project do to low quality. The couple exceptions to that were when one of those less enlightened companies hired a couple of the main contributors to clean up their mess. The only one still in business is the one that explicitly contributed back, those improvements were maintained by the core project lowering the business' maintenance cost, and those improvements were audited and improved as part of the patch submission process. It's hard to draw any conclusions, one might be that smart businesses might contribute back no matter the license and another that one shouldn't care about those that don't because they won't weather the next economic downturn. But reason by anecdote is a weak form of argument and I would really like some scientific studies before I would argue such conclusions be adopted by others.
The only reason people ask this question is because they take a simplistic "one fits all" view of Open Source.
A great many ways have been tried to make money from Open Source. Dual-licensing is one of the best. It requires a strong copyleft license.
On the other side, if you are investing your own time, without pay, in an Open Source project, having folks run away with it in their commercial product makes you feel like an unpaid employee with no rights. So, a lot of people use the GPL because of that.
Apache or BSD licensing is really good if you want everyone to use your stuff regardless of what they do with it. There are many strategic reasons to do that, for example if you are trying to evangelize a standard way of doing things (that, perhaps, ties into some other aspect of your business and will eventually make you money).
Companies that apply BSD or Apache licensing to their products are really severely limiting how they can possibly make money from that product. Having seen some of these companies fail (I've not been directly involved in one, yet) it sounds like a bad idea.
The company I'm working on now does use dual licensing.
Bruce Perens.
The GPL is simple. If you use the code, don't restrict others from using it. If you don't agree to this, don't use the code. Your business is no worse off for not using the code.
The linked article's comments should be seen in that light.
Long before Harmony existed, there was a GNU clean-room implementation of Java called Classpath. In the interests of the community, the thing to have done for free software would be to obtain implementation completeness and then 'pony up' the money to Sun to certify (Cacao/JamVM/Kaffe + Classpath) as Java compatible.
Perhaps Sun wouldn't have allowed that but... Instead, the backers of Apache sought to create a second clean-room implementation, namely Harmony (Code and financial resources of IBM, & others - according to wikipedia). 'They' choose to hire developers to implement Java again from scratch a second time in the hopes of bullying Sun into giving them the JCK for free. It would have been sensible before work started on Harmony 4 years ago to negotiate licensing. Now there's a standoff but in whose interests does it serve to have 2 almost compatible implementations? As one javalobby poster bluntly put it recently:
So in this case, the Apache license benefits faceless corporations. I believe GPL is a good license for Sun's Java, as it prevents closed forks. Apache are arguing it's good to have a JVM distinct from the reference implementation. Again, good for whom? IBM, so they can release a proprietary JVM for Websphere? Google, so they can plunder bits of it for Harmony?
In response to the above quote, Oracle may also have their own agendas for Java but at least now the code is GPL'd. Red Hat, the main contributor to IcedTea, could fork it at their leisure for the goodwill of the people - any changes they make would be subject to the GPL. Forks of Harmony don't have the same protections. And yeah, I trust Oracle more than I would IBM!
And let me tell you, you have a weird comment threshold set, buddy. And some of you people and your minimalist mode... why do you guys turn off javascript-- this place is easier with it on!
To explain this to you, mjasay:
Did you stop drinking two bottles of whiskey per day, or do you still do it? ^^
It's a sad day, when you only have to read the headline, to detect an epic failure.
Before that, at least it was TFA, which nobody read anyway. ^^
Then it was the TFS, which now nobody reads too.
Will we now have to ignore TFH too, and jump straight to the tags?
Any sufficiently advanced intelligence is indistinguishable from stupidity.
If you think so, use the GPL.
Copyright infringement is "piracy" in the same way DRM is "consumer rape"
I was having this unintended user-switch behaviour also, but it seems to have ceased in the past 5 minutes.
*knocks on virtual wood*
Reply to That ||
I also doubt customers would benefit either since giving away the software and charging for support creates an incentive to make shoddy software that requires a lot of hand-holding.
If the source is available then the customer might just ask some other developer to fix it, so your shoddiness doesn't gain you no money, maybe some bug fixes, but even this is not sure, because the consumer is not obliged to publish the changes, at least as long as he doesn't distribute the changed binary.
They dont make much from us clicking on the ads either. People who bother do register accounts become blind to them.
Slashdot doesn't directly make money from us writing comments. The indirectly make money from us because our comments give a reason for people to visit. Without them, the website wouldn't be interesting and nobody would visit... thus making this place unattractive to advertisers.
only the specific implementation of that method.
If you copy an algorithm and the code can only reasonably be written that way, then that is not copyrighted.
Nothing stops you using a GPL as an *** implementation *** of the standard, a reference of how it CAN be implemented.
If anything, actually seeing the source might shame some companies into generating better code, and cut down on intentionally malicious code by having added transparency.
However, all software companies are in the support game, and therefore have an investment in maintaining lucrative support contracts.
Reality is a slackware box running on a 386 tucked away in god's sock drawer.
While I appreciate all Stallman and FSF has done, I still prefer the BSD-style license (you're free to do what you want with this code, including not being free with your changes :). Forced freedom isn't true freedom, IMHO. But that's a philosophical debate.
In more practical terms, businesses operate with restrictions. They have fears of licensing problems, code contamination, and lawsuits and such. A less restrictive license such as BSD/Apache/X Windows (which, if I understand correctly, merely require attribution, not giving away your business code if it interfaces too tightly with open source content).
Honestly, what's the problem with BSD over GPL? So I take a BSD kernel (for example), hack it up with my fancy mods, resell it as a proprietary product. I am required to note, hey, this product uses BSD software under the hood. Any competitor is free to grab the same base software, and apply his own talents to competing with me.
I take a a GNU product, apply some of my special magic to it, and I'm screwed (businesswise, at least). I have to give away any enhancements I make. Blah. LGPL at least lets me use compilers, interpreted languages, libraries, and so on, as a bit of dodge. (I feel LGPL only exists because if it didn't, everybody would run screaming from GPL, and it would have died long ago. I can't link to a freakin' library without releasing my code? No thanks.)
I think that bears repeating: LGPL has helped keep GPL'd software in use. That a sign there's a problem there, IMO. With the lines between libraries, compilation, interpreters, interfacing, web access, becoming blurred (and Stallman wanting web services to have to release code), I think it's becoming more and more of a problem.
In a perfect happy world where all our needs and wants and income is taken care of, GPL all the way, man... But in world where one has to express one's talents to make a living, the socialistic ideal of GPL just doesn't jive with business.
In practice, I use GPL'd software a lot, and I am appreciative. But other than for the odd bug fix, I shy away from *ever* touching the source code, period; from a business standpoint, it'd be death.
On BSD style code I've used, I've gone in, made enhancements, and redistributed things; and when I found bugs in the core of the stuff I've worked with, I've contributed back. (But not my new, proprietary enhancements.) So I've been motivated to contribute more to the BSD-style-license world, than the GPL one.
If I'm rich some day, and can afford to work on some projects for free, I will likely contribute to GPL projects as much (although I still have the restricted-freedom philosophical problem). But while I'm in business, I won't spend any significant amount of time enhancing GPL code. It's sad, but it's a harsh reality of our world.
Love many, trust a few, do harm to none.
I've made another post here, where I've talked about preferring the BSD-style licenses.
To be balanced, I should mention how I have dispelled FUD related to the GPL in the past.
I've had a couple of products in the past, that used (loosely coupled) a few GPL packages. They were done as web services, so there were no licensing problems (although doesn't the latest GPL start going after that? Ulp.)
Anyhow, GPL was not a problem for us as a web service. However, when the time came that we were approached to license our product to other major players, the question of the GPL came up. These players wanted to run their own web services based upon ours. Fair enough. I told them: "okay, here's our core product; and, by the way, it has these outside dependencies that we won't redistribute, but you'll have to scare up yourself, install yourself, and use yourself." It really wasn't a problem. We listed the GPL requirements, they grabbed them, and fairly used them within the GPL license.
The one thing they couldn't do was modify and shrink wrap the product including those GPL components (without giving away the source). But they just wanted to run their own service, not sell the product for others to run the service, so it was a non-issue. And from our standpoint, we didn't want them to shrink wrap the product and create more competition (our contract specifically forbade it, in fact). In this case, the GPL, somewhat ironically, provided us some protection against them more freely distributing the licensed product. :)
Love many, trust a few, do harm to none.
In this one, the BSD has languished and GPL has been getting all the action.
PS if you think BSD is better, why not BSD your code?
Ooops.
Wrong flame war.
Sorry.
Eric Raymond is not relevant and hasn't been for years.
He goes on to say
There's some useful discussion in the comments, but you'll probably have to wait until the slashdotting dies down before you can read them.
It's actually pretty difficult to contribute to dual-license GPL projects - they'd rather do the changes themselves and not risk legal hassles. What they want is bug reports.
When I was maintaining the ISC DHCP distribution (BSD license, BTW), I dreaded getting large patches, because I'd have to go through the whole damned patch and figure out what it actually did, and correct it. I much preferred bug reports. The idea that patches are why people open source things is really a red herring - sure, if you get a regular contributor who's really good, you can start to trust their work, but that only works for projects like linux where you have a huge number of interested geeks.
So really, what's going on with a dual-licensed model is that the owner of the copyright is using the FUD of the GPL to get people who don't trust open source or don't want to open source their own code to pay for non-GPL copies. At the same time they are offering the GPL version to the community of people who like the GPL, which spurs adoption. It's a win for everyone.
The problem with the BSD license is that the only way to get money out of it is charity, because there is no license FUD. Nothing wrong with charity, but it can make paying the bills a bit difficult.
To answer your question - no. If Linux were BSD licensed, it would have essentially been another BSD Unix. The big Unixes could use code from BSD if they wanted and they kept themselves closed and eventually died (except for IBMs Unix). BSD itself is not nearly as well supported as Linux.
True. Well, maybe. Firefox? I guess charity.
But you are pretty correct. But honestly, the kinds of contributors needed to make a "real" application are from people who wouldn't get paid using either license. I'm talking UI people, QA staff, marketing departments, etc...
Actually, I dont know what I'm talking about. You raise an interesting point. That still doesn't mean I can't feel a bit queasy about dual-license stuff. If I was the head honchos at the GPL factory, I'd be a bit queasy seeing the GPL brand become "MySQL, Java, and other companies who only use the GPL to squeeze money out of people". It isn't a very healthy brand for your product. I think it would be wise to distance myself from companies who use the GPL in this way. But what do I know!
My experience is that BSD licensed software tends to have a closed version that I have no access to and that has all the features I want
Apache licensed software is very open (but there are closed versions as above) but the open versions seem to be "complete"
GPL'd software seems to be mostly complete and open....?
Note this is only my (limited) experience but GPL'd software feels more open ...?
Puteulanus fenestra mortis
So I might be wrong on this... but the dual-license guys seem way more blatant, probably because I get a lot of satisfaction posting here, but dont really get much satisfaction contributing to some faceless corporations open source project.
So don't. If it's GPL you can fork it yourself and do what you like within the GPL.
I doubt many programmers on this board want to be in a position that the work they produce for a company is essentially worthless and the way to move up is through the tech support department.
It doesn't work like that; instead, customers pay for directed development. In practice this is how product features are driven today; %SUPER_MEGA_CUSTOMER% says "I want Orifice to curve to the left, and I'll update all 69,476 seats." Then "the vendor" "leaks" the idea of the feature to the market (aka "floats it") and decides how much money there is to be made. An estimate of what it will cost is generated, and then some scheme for milking the money out of the customer that wants the feature is meshed with a release schedule... Then marketing issues an inane edict to engineering, and the fun begins.
In the FoSS model, you have to get all of the money from the people who want the feature, so maybe you've got a smaller audience to run the idea past. When enough customers want (or might want) the feature to convince them that it's time to upgrade, you implement the feature in a new version (first in the OSS product, for testing) and then you later issue a version upgrade, complete with invoices to your paying customers. Maybe you charge them for the upgrade support, if they're on a service-based model.
I also doubt customers would benefit either since giving away the software and charging for support creates an incentive to make shoddy software that requires a lot of hand-holding.
It seems to work for MySQL, and others.
"You're right," Fisheye says. "I should have set it on 'whip' or 'chop.'"
Just to be clear, I had boiled things down to software either as a tool, or as a product, but here you bring up more complicated licensing schemes where folks try to keep the software as a product and dabble in open-sourceness for other reasons. I generally agree that doing so seems kind of weaselly, at least from my (admittedly limited) perspective.
I see your point, but I think it might be a bit of hyperbole to describe such coding efforts as "essentially worthless" -- somehow Red Hat seems to do well in this space. :) Plus, I think you might be unintentionally discounting all the systems integration work that often goes into corporate deployments -- this very often includes gobs of code to wire things together, and that code itself isn't free (as in beer), even if the initially provided FOSS software is. I also doubt IBM would get behind Linux quite as much as they have if there weren't a good business case to be had.
Cheers,
"What in the name of Fats Waller is that?"
"A four-foot prune."
I've decided to start my own license called the BML (Buy Me Lunch) license.
You can use the code anyway you want with these provisos:
1). Give me credit for my work. (A simple "Thanks David" in the Readme file is fine).
2). If they have any neat changes, I'd like to incorporate them into my code. They don't have to, but it would be nice and this way I'm the one responsible for maintaining it.
3). Most importantly: If they ever get to town, they have to buy me lunch.
People certainly do contribute to such projects! FLTK has a GPL+linking exception license, which means that contributions can end up in closed-source for-profit software, and plenty of people submit changes.
Mostly because their fixes get into the official version and thus they don't have to keep patching each update, and they can stop worrying about changes being made to the official version that conflict with their patches.
There is also an ego thing. If somebody else fixes the same thing and contributes their fix, they will get all the credit for doing so. Also they may fix it in a way that you think is horrible and far inferior to your solution. You have to preempt this by contributing your code first.
It seems to work for MySQL, and others.
Because most of their revenue is from selling the software under the proprietary license.
Bottom line, I won't touch GPL for anything that might make my mainline code become a derivative work and force it all to become GPL'd. BSD'sh licenses cannot do this to my mainline code, so I can use their stuff and contribute anything I think they will find useful.
I have a news flash: the GPL has no such mystical powers as being able to force your code to "become a derivative work" or "become GPL'ed".
If your code is derived from some other code base, then it is. If it is not, then it is not. The GPL has nothing to do with this. If you want total control over your source code, don't derive it from anything you don't own, no matter what the license is.
The GPL also cannot force anything else to suddenly become GPL'ed. If you derive from GPL code, then yes, your code may not be legally redistributable unless it is also available under the GPL. But again, no magic: you chose to derive, you have to play by the rules. This is true of every software license--commercial, Open Source, whatever.
"Not an actor, but he plays one on TV."
"If it contains someone else's code under GPL, you can still make money from the modifications, but you won't make a monopoly rent from it."
You won't be able to pay your rent from it.
Say you contribute to a dual-license project like MySQL. If you sign away your contribution to the company, then it's true that they get your work for free. But, you can contribute and not sell your work. Then the company can't use it in their proprietary other-sourced version (unless it's GPL-compatible, of course).
Basically, you can always fork the project.
I think, though that it is more about helping improve the software. If the company doesn't contribute at all to the project, then I would agree with your point, but the dual licensed code that I usually see, the company makes the significant investment initially in creating and starting the project and generally contributes the most on a regular basis. In that case, as a contributor, your payment is actually paid upfront in being able to view source and use the code (sometimes at no cost). Those who don't contribute at that point are freeloading on the project, which is fine as long as the community behind the project is OK with it.
or, one person's junk is another person's treasure.
The Free Software Foundation considers the Apache License, Version 2.0 to be a free software license, compatible with version 3 of the GPL.
Well, the customer management system is both a tool and a product. A tool for the 'food maker', a product for the customer management system vendor. How does this help us justify whether the software should be gpl or not?
Say, in theory, that you decide to fund your company by supporting a single Open Source product. Put yourself in the customer's place:
The customer will have to spend a lot of time just figuring out what is breaking, so that he or she knows who to call.
The customer will then have to spend additional time proving to the vendor that something is broken in their product, while the vendor points elsewhere: hardware, OS, someone else's product.
The customer will have to manage integrating all of these piece-mal support companies into their own support solution.
This is total hell for the customer.
So, it works out that to offer support on a single Open Source product, the vendor has to make a deal with an integrator who will service everything, both hardware and software, and funnel business to the vendor.
But the vendor would rather make a larger profit by using their own resources when possible.
So, the one-product Open Source company doesn't succeed in offering support business, long term.
There is one Open Source company that pays dividends today. That's Red Hat. Most of them make a big noise, but aren't terribly profitable if at all. Once in a while we get one of them to admit it.
Fortunately you don't need companies to make Open Source.
Bruce Perens.
There is an easy answer to this. Don't make the software as your business. Most of the successful Open Source applications are made by Open Source projects in which businesses participate, not businesses whose goal is to make the software.
Am I saying that Open Source business doesn't work? Most of the time it does not. It depends on what you are doing.
Bruce Perens.
Many dual-licensed projects are perfectly happy to accept patches, as long as you sign over the copyright or the right to relicense, and swear that you are the author of work and don't know of any infringements in it.
The problem is motivating people to sign that. I think I know a way, but I'm still working on the product for my new company so don't yet have proof.
Bruce Perens.
YKUTW "proprietary". IDNTIMWYTIM.
He was on the Freespire board and never heard him once say a word about his buddy Carmony when he was attacking us open source pirates.
No, no...
That would take some courage and also put away his rabid hatred of the GPL.
He seems to lead a sad, pathetically angry life and much of what he says is covered in spite and vitriol.
Then again, the words open source have totally been coopted and lost much of its meaning.
Maybe he was hoping someone would care about his 'battle' but most of us have moved on and have tried to live with each others licenses.
If he had written this here under a different name he would have been labelled flamebait.
A sucky one though. I doubt many programmers on this board want to be in a position that the work they produce for a company is essentially worthless and the way to move up is through the tech support department. I also doubt customers would benefit either since giving away the software and charging for support creates an incentive to make shoddy software that requires a lot of hand-holding.
That might hold true until your competitor realises what you are doing and makes a better offer to the customer.
As a business customer I want Free as in Freedom software (to avoid vendor lock-in) that is easy to use (to lower total-cost-of-ownership) and comes with "enterprise" level support (for the edge cases I create that eventually break things in some way).
As a vendor I want software that is cheap to build and maintain over the long run, and I want to build brand loyalty (even in a fiercely competitive market) by delivering a great product, and I don't want to have to maintain a huge support staff that eats into the profits I make by selling support contracts. Enterprise customers will pay for support simply because it eliminates some risk, even if they never actually have to pick up the phone and use it.
They dont make much from us clicking on the ads either.
Wait -- Slashdot has ads? Why can't I see them?
Am I missing something?
Those who do study history are doomed to stand helplessly by while everyone else repeats it.
Everybody loves him.
(Except me.)
factor 966971: 966971
Well, the customer management system is both a tool and a product. A tool for the 'food maker', a product for the customer management system vendor. How does this help us justify whether the software should be gpl or not?
The food maker can invest in GPL software and meet the need permanently. If they choose to fund closed source software and use it, they make themselves hostage as they continue to make food.
The system vendor who distributes closed source code holds people hostage long after the work is done and it's time to move on to some other project that needs doing. They use people like the farmer. People must continue to work, endlessly, so the executives at the system vendor organization can live like kings, with no end in sight, and with no need whatsoever.
The farmer and the employees of the system vendor should get together and string the system vendors up by the neck for trying to make them all into slaves, work together to ensure the farmers infrastructure is up to snuff, then work the land together and all eat well and work less. Then they can use their spare time to make the nice things the executives would have demanded if they wish, for their own enjoyment, or they can catch some rays at the beach... that's up to them.
It's a big, ugly, convoluted system of normalized and socially ratified parasitic behavior where no ones hands are clean and pretty much everyone is a victim, and it's not easy to see what's really going on by intent, but that's the general nature of the situation.
-1 Uncomfortable Truth
because of the free one.
Try before you buy.
Used all over the place especially for big ticket items (would you buy a ferrari if you had to sign something like the MS EULA and couldn't get a test drive?).
They are a commodity item and not a monopoly one.
Yet there are potato farmers who grow potatoes and make enough money to pay all the workers, all the rents, taxes and other expenses and have profit left over.
So why do you think you can ONLY make money to pay the rent if you get to gouge your customer who has no choice (the definition of monopoly rent)?
Ah, should've guessed. You are a bigot. Your handle says so.
That is essentially the BSD with the "Buy Me Lunch" clause. :=)
There were good posts above but this has devolved into a typical flameware between people who see the GPL and the BSD as the only two possibilities.
What I would very much like to see is something that is "what people think the LGPL probably means before they read the fine print":
You can use the source code unchanged in any way you want in your software and distribute the result. However if you modify the source code to use it in your result, you must release your modifications (but not the rest of your program) under the same license.
In my opinion additions that don't require modification of your code are going to be creative work and thus should belong to you. But you should not be able to "steal" my code by making tiny changes to it and closing the result. I think a lot of people feel the same way.
Now this sort of license has been made dozens of times, and is often called "GPL plus a linking exception". The problem is that there is no common three-letter name so nobody can easily refer to this license, so there is license proliferation.
I think the FSF is to blame for forcing thier philosophy by activiely avoiding creation of the license described above and giving it a nice short name with a 'G' in it. No other organization seems to have the clout of the FSF to get a name standardized.
There are also commercial intereste to blame, they know this sort of license would address all the arguments against the GPL without removing the ability to compete that the BSD does. Their tactic seems to be to argue that there is no middle ground, and also to pollute the license namespace with hundereds of BSD licenses so that any such license that gets any popularity is buried.
Either we write code he can take and hide from us (with him) or he'll refuse to use it and slag off the GPL (against him).
Does he want to get paid for his coding? Why? Surely if his employers want to pay him nothing, he should just accept it and write the code for free. If his employer improves the code, they can if they like give him the code changes they added, but he shouldn't DEMAND payment.
And you do the same.
Either we are with you and drop the GPL or we are against you, keep the GPL and you will shun us.
Is there any wonder why we decide "against you" ?
They must GPL it.
But they still own the code.
If you want to make your software free of restrictions, then place it under a BSD, MIT, Apache or other unencumbered license. But if you desire to control, regulate and manage what other people can do with your software, then use a restrictive license like the GPL. Many businesses like the GPL because they can be "community based" while still restricting their competitor's ability to leverage the software.
What I have never understood, though, was the use of the GPL for non-commercial community software. The usual excuse is that "Microsoft can't steal my code". That displays a shocking ignorance of the nature of information. No one can take your software away from you, or away from your users. They might be able to fork it, but your original software is still there untouched. The reciprocity of the GPL can be very useful, as with commercial open source, but it has nothing to do with protecting the software. Instead it protects the fragile sensibilities of the author.
ESR is one who gets it, who understands that free software does not need to be protected and coddled beneathed layers of licensing restrictions. Anything beyond attribution and warranty disclaimers is too much.
Don't blame me, I didn't vote for either of them!
The question is how you want to make money?
Through consultancy or by selling software?
If you sell software, GPL in a dual license setup seems to be a succesfull combination. The GPL helps in keeping the usage of code transparant.
If you do it through consultancy (implement something for a specific customer) I would pick Apache. It provides the company you worked for security that the specific stuff is theirs without any strings, yet you can create a nice community around it.
YKUTW "own". IDNTIMWYTIM.
Some sort of dividend? .... simple enough.
Sounds interesting, and
First, as *BSDs show, the GPL is not a sine-qua-non for having a pretty good open source operating system. This piece of evidence is frequently neglected by the wishful thinking/fallacious thought process of GPL fanboys or members of the Cult of Stallman. Going further, the adoption of FreeBSD userland code in Mac OS X has allowed for a truly great thing, a Unix for the masses (and, BTW, Apple has contributed code back as well as hired FreeBSD developers).
Second, most big open source projects are business-friendly through their licenses (look in there for the LGPL or exceptions or other licenses): KDE, Google software, Firefox, Perl, GNOME, etc.
Third, to stay away from the obvious, I'd like to consider the fact that there would be other, better, languages to program software in Linux, with faster and safer development cycles. Specifically, I'm talking about Eiffel and Ada that had powerful IDEs and compiler released under dual-licenses (GPL is your project if your project is GPL) but that didn't result in even a bleep on the radar screen of developers. Now, I know there's a cultural barrier (overindulgence in C/C++) but the fact is that releasing dual-licensed IDEs and compilers didn't help.
Third, the Church of FSF gets it all wrong by focusing on "freedom for code." Code is an abstract, inanimate thing. "Freedom" as a category applies to humans. Humans should be free to choose what to do with code. Open-source code can't be "stolen" because the fountain of resource keeps on giving. The Church of the FSF is a moralist cult.
Fourth, there is no way small software houses can compete with huge firms if they release GPL code. Everybody knows this. They'll take your code and give it to their staff. Greenspun wrote about this eons ago.
Finally, fifth, quit with the non-proprietary code hating. Currently, what's needed for the widepsread adoption for, e.g., Linux, is the hability to use a machine as a normal machine. Therefore, we need proprietary codecs, unless all the free software signal processing freaks (you there?) get together on a project like the BBC dirac, which is not happening for whatever reason... Otherwise, e.g., Linux will not be usable. So, the community's got to stop hating on distros that mingle Linux with those codecs, and stop hyping distros that require too much tweaking. Right now, throw some RAM and something like Matisse and Linux can impress people as much as, say, Vista.
Main difference between the BSD license and the GPL license: one is from California and the other is from Massachusetts
For businesses, I can certainly understand the appeal of a BSD style license. The problem is that you will potentially end up with a situation like what we have with Apple - all of the work that went into BSD was stolen by Apple and Macs don't allow proper code sharing.
As an end user, I always want true GPL software so that I know it will be mine forever.
If I were developing software to integrate with some proprietary code, that would obviously make the decision a little more painful. Unless one is willing to make the full RMS kinds of sacrifices for freedom, the occasional BSD style of license will be required.
Maybe a bit OT, but BSD can create problems for a company's legal department because it is really just a template for a license. Every variation on BSD has to be vetted individually as a new license. If you use MIT or Apache instead it's much simpler for the lawyers. MIT in particular seems to be the least suspicious to lawyer types. (I think they recognize the name.) The GPL is probably not as well understood as it should be, but once the lawyers have encountered it, they don't have to repeat their work again.
Free software isn't worthless. It's priceless.
I am glad that the GPL exists. It's an excellent license, does exactly what it aims to do, and - unlike almost all of the other options - has actually been tested in court and stood up.
Remember that the Real World MMORPG is a lot like EVE - ruthlessly capitalistic. There are huge corporations out there with no morals, ethics or reasons to not crush you if it means a profit. Like all legal documents, these are the reason you need the legalese. I'm sure there's a lot of corporations with (at least some) ethics. And a lot more common people where a simple "hey, don't claim it's yours" as license would do.
But those are not the people that you'll have to take to court. Those are not the people that will try to steal your hobby project that you put five years of your life into, and sell it as their own.
So by all means, pick whatever license suits you best. I've released stuff under at least four different licenses over the years, as well as having put some simply into the public domain.
But know why you pick which license.
And remember that ERS has an agenda (just like RMS, of course).
Assorted stuff I do sometimes: Lemuria.org
Apache license more widespread implies GPL less widespread. But if there were not the sheer amount of GPL software to fall back to, closing up source by embracing and extending would be surely more effective than it is now. More big firms would be tempted to do it. Apache license would soon become something used by academics and startups to favor the take off of projects before finding some venture capitalists.
GPL and linux have a positive impact on closed source by their mere existence as an alternative. Remember the cost, bloat and incompatibilities between versions, when most of the popular stuff was commercial.
---- MISSING MISCELLANEOUS DATA SEGMENT --- [sigdash] trolololol
Don't make the software as your business.
Consider firms selling router/applicances/etc with FreeBSD.
IMHO, unless you're IBM (or, realistically, just a worker for IBM), Linux makes this very, very hard.
Main difference between the BSD license and the GPL license: one is from California and the other is from Massachusetts
Sorry, I forgot to post the URL:
http://www.freebsd.org/commercial/hardware.html
Main difference between the BSD license and the GPL license: one is from California and the other is from Massachusetts
The alternate model of giving the software away for free and charging for service instead adds an interesting wrinkle to the equation.
As a developer, I'm not a big fan of selling services. So what about a hybrid approach where the code is open, but you still have to buy it -- so it's not free, it's libre.
I'd call this hybrid license Fair Source, a cross between GPL and the Software Bill of Rights.
These products would be commercial in the sense that anyone could start a real business, invest in marketing (a big lack in current FOSS proejcts), but still retain the coolness of open source.
Here is political scientist Steven Weber, writing about the tendency toward different governance styles for projects using BSD-like and GPL licenses (when he writes "Linux" he means it as an exemplar, not the only instance):
Weber, Steven, The Success of Open Source, 2004, pp. 62-63.
Assuming his claim is true, this may be because developers see the two licenses differently (e.g. contributors may feel greater incentives to contribute to GPL projects, or they may have principled reasons, or it may have to do with their identity and membership in a community). Or it may be because of the kinds of projects that pick the licenses: the typical BSD structure he describes mirrors that of big companies, perhaps because they tend to choose such licenses. Personally, I suspect all of these factors contribute. But then I find them to be compelling reasons to pick the GPL.
Even after years of conversations with us in the FLOSS community, Matt still doesn't get it. He's completely focused on “businesses with a codebase that release it under some license”. He doesn't understand community-driven software that isn't tied to on specific corporate entity.
The GPL is specifically designed for community-driven software that is not tied to one company. Matt could very well be right about the limited, pro-corporate world he occupies; it could very well be better for them to use the Apache license.
However, individuals and very small contracting agencies benefit best when they can be put on equal footing with the big guys. The only types of licenses that do this are copyleft licenses.
Finally, declaring that people's life's work trying to make the world a better place — even if you disagree with their politics — is disingenuous at best. I've spent most of my adult life working to make the GPL and the codebases around it better. I'm sorry to hear that Matt thinks I've been busy dumping radioactive waste on his world.
If your goal is wide acceptance in the business world, then yes, the Apache license or BSD or, for that matter, public domain is far better than the GPL in most cases -- other posters have noted the glaring exceptions.
If your goal is maximum utility for individual users, then the GPL or a close relative is the way to go.
The thing about ESR and RMS is that they approach the issue from diametrically opposed positions and assume that everyone must follow their lead, when the fact is that motivations vary. I was interested in Free Software from the beginning for reasons that were (and remain) essentially altruistic: I wanted to help develop software that would be useful to individual users and accessible to individual developers of like mind. I don't care one way or the other if anything I've done becomes especially popular or widely adopted in the business world, though I have contributed to projects that were.
ESR and many of his supporters, on the other hand, do care very much whether their work is adopted by the corporate world, and many of them are hoping to profit from it. While that's not to my personal taste, it's all fine and well, and I support their freedom to take that approach.
That said, it has often seemed to me that if you want to write software for the corporate world and to make decent sums of money at it, it makes a lot more sense to just get a programming job at a corporation or start a closed-source software company. I know there are a lot of folks out for world domination with varying amounts of tongue-in-cheek, but I've never been convinced that there is any tangible benefit for individual users (including myself, when I'm using rather than coding software) to be derived from massive corporate adoption of most FOSS software. Conversely, there is a great deal of risk, not to corporations playing with "viral" licenses, but to the freedom of free software itself, when you play games with large corporations with lots of money and attorneys. In such a contest, the small FOSS project is always overmatched unless it aligns itself with another large corporation, which entails even more risk.
Anyway, the long and the short of it is that we have many different kinds of free/open licenses for the simple reason that developers have many different goals for their projects. One size does not fit all, ESR and RMS to the contrary.
Proud member of the Weirdo-American community.
Bollocks, tell that to apple. You can take BSD licenced code and keep it - no upward financial contribution required,
Do you live in a hole ?
If you had said the GPL then you could be right but the BSD licence is specifically not built like that.
From your post: "...freedom..."
From ESR's blog: "...efficiency...economists..."
I think the two of you are discussing entirely different concepts.
Like this. Let's assume you are a farmer who knows how to program a software system. Maybe you're a hobbyist programmer, or a farmer that used to be programmer before you inherited your farm, or the younger son a farmer sent off to school to learn how to use the latest machines and techniques. It doesn't matter. Let's assume you look around at various products that help run farms and none of them seems quite right to you, or quite worth the money, so you write your own. It's a great success, and soon other farmers are asking to use your software and suggesting improvements. You have essentially three options at this point: You can just happily use your software without giving to anyone else, you can go into the software business and sell your software (maybe in addition to, maybe instead of your farm produce), or you can give your friends and neighbors your software when they ask and help them out since software isn't your business.
In the first case, licensing isn't really an issue. You have your software, not one else does, and that it isn't likely to change.
In the second case a proprietary model might be best for you (at least according to the previous poster). You are trying to sell your software and giving anyone and everyone access to your source code might make that hard. You could give away the software and sell service, but now you're really getting away from your core competency (farming).
In the third case you might want to consider the GPL. It gives you several advantages. It prevents you from being sued for using your own software if someone else tries to commercialize it (Strictly speaking this shouldn't happen anyway, but the GPL provides another layer of protection). It makes sure that if someone else modifies and re-releases your software you can see what they did and cabbage any improvements they made (which might be considered a form of "payment" for you releasing the software in the first place). It makes sure you get credit for the software (which might or might not be important to you). It provides a way for other farmers to modify (or pay someone to modify) your software and release their versions out into the wild, or submit them to you as patches to the "main tree". Generally it provides you with a way to give your work to people you want to help without totally losing control of what you wrote.
I don't need a million points of light, just two points of multi-mode fiber and a 10 Gig-E router.
My customers are putting Linux in new car dashboards and cell phones.
Bruce Perens.
Using open source allows you to get third party contributions back. Once you decide to go down that route the most important difference in my opinion is that with Apache a competitor can use Embrace, Extend and Extinguish on you. With GPL they can't.
The Apache and BSD people don't care, while the linux and FSF people do care. Thus their choice of licenses. In for-profit businesses the trend seems to be that successful smaller open source businesses tend to prefer GPL. Big businesses that make money otherwise such as Microsoft may use BSD which has the same philosophy (among other things). Alternatively huge businesses that have no visible competitors such as Google may also prefer Apache like licences.
It all comes down to balancing risk and convenience in the end.
That is possible. What I am thinking of is a covenant to continue the development as Open Source for two years after the contribution, or to remove the contribution.
Bruce Perens.
Long time, no here from Eric on /. Now, back in the last century, Eric would tell BSD developers how much he liked say FreeBSD and thought it was better than GNU/Linux (when BSD ppl were buying lunch) then talk about how wonderful Linux was and never mention BSD later that same day.
So, other than to rile some people up to make his name known - is he now being paid by some BSD-centric group?
There will be a Firefox extension for opting them in so you too can enjoy them.
NB: The message above might reflect my opinion right now, but not necessarily tomorrow or next year.
Seriously, troll much?
It's not so people can't take the code away, it's so they can't even use it without giving changes and enhancements back.
What's shocking is your ignorance of the reasons behind people using the GPL.
They still own the code.
It is their code.
If they keep it to themselves, there is no distribution and they don't have to disclose a thing.
They still own the code and therefore it is propriatory.
I'm sorry, but why exactly are you implying that you can't dual with BSD as well if you own the code and accomplish the same thing? A public BSD licensed version and a private proprietary licensed version with your extensions to the core.
Hell, someone else can take the BSD licensed version and extend it with their own private proprietary extensions and distributed it as well.
By your argument, the only reason to use GPL is to make it harder for others to make money of the GPL version.
With Mac OS X you're confusing two parts of the system as if they were one. The OSS portion of OS X is perfectly usable. They contribute changes to the OSS portion all the time so they don't have to maintain patches and deal with forking beyond a certain point. That in and of itself is reinvesting back into the product that they are using.
Purely OSS projeccts are for geeks alone to use. There isn't a large scale OSS project anywhere that can be considered end user ready with a good interface, reliablity and good performance that isn't backed by some company using it to its for its own means.
My point is simply that you might want be a little more considerate of the companies who are actually footing the bill for development and management of the projects that matter to more than developers.
Persistent Volume manager for Kubernetes - https://github.com/dwimsey/openshift-pvmanager
You're more or less imaging what he's trying to say. The person who released the code that Apple then took is getting no benefit from Apple using the code.
In fact, it's pretty difficult for Apple to give them benefit even if they want to. Since companies are supposed to work for a profit, every major code contribution to a BSD project should really be weighed up, comparing the benefit it migh give to the competition againts the maintenance benefits of sharing. Since that's a pretty difficult calculation to make it needs serious effort and so most programmers just take (short term) the easy option and don't bother. Long term this means that BSD projects inside corporations tend to end up dead or proprietary.
Overall that means that BSD is a poor license for a company to release under or make long term commitments to. It's a good license for taking small bits of code for other projects, however.
=~ s,(.*),<sarcasm>$1</sarcasm>,g if any_point_you_wish();
That's true in theory, but doesn't really match my experience. Although maybe my patches just sucked... :')
My big worry if I were to do a project like this would be that someone would sign the agreement, but then represent something as their work that wasn't, and I'd be left holding the bag. For small patches, that would be unlikely, but anything substantial would be really difficult to accept. However, I will admit that I am thinking like an individual, not like an LLC. In the latter case, I might feel a little less paranoid.
/*
* "THE BEER-WARE LICENSE" (Revision 42):
* wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer in return Poul-Henning Kamp
*/
from http://people.freebsd.org/~phk/
I think the article has a dogmatic approach and lacks the bigger picture.
If consumers feel they have to less choice / have to settle with too less bang for their buck then there is an itch to scratch. If the itch is nasty enough to be relevant either the market provides a cost beneficial way to scratch that itch or people get mad as hell and do it themselves. If you want to scratch your own itch with code you write yourself, you know how to scratch it best. If GPL does it, fine. If my propriety license does it, fine too. If some Developer religion suits you, who gives. There is choice how to scratch an itch, and that's what counts.
That's 100% incorrect.
An original author (as stated in the parent) always has the right to dual- or multi-license his code any way that he wishes, even with two totally incompatible licenses such as one GPLv3 and the other proprietary.
A downstream re-developer can't do that, and always has to stick with the original licensor's original choice of license, but that restriction does not apply to the original author.
How do you ease their concerns about the FSF dudes going after companies like Tivo or Cisco? I mean, if I was a hardware guy right now, I'd be *very* concerned about touching GPL stuff. Almost like they dont want me at the club.
BSD wins for open source business hands down since it lets the developers (the only ones who actually matter from our point of view) do what ever the heck they want without being forced by communistic licensing terms of the GPL to give away our competitive advantage!!! If you don't like that too bad for you. This is our point of view. You don't have to like it or accept it for yourself but just don't force your commune upon our income earning potential. Thanks.
If you want corporate users to use your code in their products, use a BSD/MIT license. Then they get to use you work for free with out any obligations.
If you want corporate developers to contribute to your project, neither GPL or BSD are on your side unless you already have enough momentum to make corporate have to work with you on your terms.
My employer has guideline for handling open source software. Everything has to get cleared. If we are using GPL in a product we need to provide a plan of how and when we will stop. I we want to use GPL in a product new product we have to write up a proposal so that it can be rejected. There are very few exceptions to this.
If we want to use BSD code in a product, we are usually ok provided we jump through a mess of legal hoops to make sure the code doesn't have any legally poisonous contributions. Contributing back is another issue altogether since our competition code use code we write the same way used the BSD code.
Open source needs to compete by being better, not corporate friendly. Corporations are nobody's friends. They are purely seeking profits. Anything that appears to be done out of kindness or as a friendly gesture is being done in the hopes that it will lead to more money.
Corporations are not using Linux or Apache because they are corporate friendly. They are doing it because the code is too good to ignore. The choice of putting up with the GPL or a BSD license versus write maintaining & using a home grown replacement or paying to license a proprietary replacement is too much in favor of Linux and Apache.
The difference between GPL and BSD license in this case is that BSD allows vendors to trick themselves into thinking they can go proprietary with the code base and go it alone as we saw with all the UNIX vendors who wrote their own bastard derivative of BSD. I don't know how many derivatives there are of Apache.
How do you ease their concerns about the FSF dudes going after companies like Tivo or Cisco? I mean, if I was a hardware guy right now, I'd be *very* concerned about touching GPL stuff. Almost like they dont want me at the club.
The FSF is really quite predictable, especially with respect to the GPL. As RMS says it, the goal of the GPL is to ensure that "where the software goes, the freedom goes with it". If your interests are aligned with that goal, then you really have nothing to worry about. If not, then the FSF probably *doesn't* want you at the party.
In a way, the FSF is just like any other business. They provide goods and services in exchange for something they value in order to further their goals as an organization. The difference is that while cash is a great way to further the goals of a publicly-traded company, GPL compliance is a better way to further the goals of the FSF, which are basically to ensure that all people are ultimately in control of the software they use. Like with anything being sold, it's up to each potential buyer to decide whether what they get is worth the price.
http://outcampaign.org/
Read the complaint. Don't do the stupid obvious license violations alleged in the complaint. Then you'll be fine.
Nobody violates a Free Software / Open Source license for a smart reason. Cisco hasn't got their compliance act together.
Bruce Perens.
If some software house is prepared to write and maintain 80+% of a project, and let me use it for free (GPL/BSD/etc) then they can have my patches. It seems like a fair deal. If that allows the company to employ programmers to keep the project running, that's fair. Look at something like VTK. It's a cool library. Some customers want to pay, to keep their source closed. Okay, I can live with that. But I (who use the software as a means to an end) am happy for anyone to have my mods - it doesn't cost me anything, but the open licence allows me to use it.
As for programmers code being worthless because the company don't charge for the code - I think you need to sit back and think about this. If there was no code, what would the other guys be supporting? Where would the income come from? How the company gets income does not determine where the value is (most mobile phones are free with a contract, but the engineers who design phones/protocols/etc still seem to manage a decent salary).
A danger with dual licensing is that the GPL version can be forked and you lose control of the project, and the ability to sell license free versions (since now the leading version contains code copylefted by people outside of your company)
I wasn't implying that you can't dual license with BSD but that the BSD license in itself already permit closed source version from others and thus nullifies the advantage that the GPL has over this.
As for the GPL being better at making money, I'm myself a citizen and not a company but from my understanding the GPL will create more wealth for the product and the competition might be based more on who can adapt it faster and offer the best suppport and thus be more centered around what open source / free software is all about while the BSD allows this game to be played in the world of proprietary "advantage" which I don't believe is a good idea and from a consumer point of view I don't support / not interested to put money in.
As for Mac OS X, I'm no expert there either (Haven't had a mac in years...), but having a Darwin part that Apple uses to embrace and extend it in ways that make the Darwin OS some kind of beast of it's own without being able to run everything that the "full" Mac OS can run is i think a bad move. From my user point of view this is something that is annoying as it seems that i can't really choose which version i want to run if i want to be free to run the apps of my choice on that OS. Missing 3D/GUI libs among other things will be a problem and this really makes those things 2 different OS in the end for the users they are aiming for so they're just running that Darwin ecosystem in a dead end world and having free bug fixing but without any input from the community or real "cooperative-competition" possible. As if QT had their 2 branches where the GPL one was incompatible with the applications compiled with the proprietary one on common systems. That would be a bad move too.
But of course i recognize that companies have been helping the software growth of Linux/*BSD/etc a lot and I'm glad they did but in the end the values lies in the freedom of that software and licenses that don't support that freedom are detrimental to the economical value of that software as i think it'll slow down development in a commercial context. Companies who do provide code and resources do so because they understand the benefit that this will give them and getting involved in a part of the code is also giving you some authority on that code and thus helping you selling your support and opening your market to a wider audiences than with an extended closed version.
Then again, I'm sure BSD / Apache / ... but my understanding overall is that unless you are all big juggernauts confident that you'll always have more fund than the other to support development, it's safer to go with the GPL and wiser from a community of user point of view.
Oops, last line should start with: ...
"Then again, I'm sure BSD / Apache / etc have their place somewhere"...
After my last comment, i went to look a bit at wikipedia, and, what do we get:
http://en.wikipedia.org/wiki/Darwin_(operating_system)
----------------8----------------
On July 25, 2006, the OpenDarwin team announced that the project was shutting down, as they felt OpenDarwin had "become a mere hosting facility for Mac OS X related projects," and that the efforts to create a standalone Darwin operating system had failed. They also state: "Availability of sources, interaction with Apple representatives, difficulty building and tracking sources, and a lack of interest from the community have all contributed to this."[15] The last stable release was version 7.2.1, released on July 16, 2004.
----------------8----------------
So I guess I'm not the only one feeling that way.
I'm sorry, but why exactly are you implying that you can't dual with BSD as well if you own the code and accomplish the same thing? A public BSD licensed version and a private proprietary licensed version with your extensions to the core.
You're right, of course, but what the GP failed to mention (but probably thought about) is that with the GPL you can have a dual-licensed product *without* propietary extensions and still have a workable business model, all thanks to some businesses' fears of open-sourcing their own code. Not so with BSD.
With Mac OS X you're confusing two parts of the system as if they were one. The OSS portion of OS X is perfectly usable.
But how useful is it? the F/OSS part has almost none of the features that are commonly associated with OSX, can run practically none of the OSX-exclusive applications, and I've yet to see a single reason to use it instead of Linux or the BSDs. And I believe that was the point of the GP's argument, not that it was broken and couldn't even compile but that it could hardly be called OSX.
Purely OSS projeccts are for geeks alone to use. There isn't a large scale OSS project anywhere that can be considered end user ready with a good interface, reliablity and good performance that isn't backed by some company using it to its for its own means.
Which single company do you consider is behind the Linux kernel, for instance? or GCC? it's obvious that once a project gets big and useful enough, companies will start investing in it but that doesn't mean they're controlling the project's direction, certainly not if there's more than one contributing large amount of patches.
No problem is insoluble in all conceivable circumstances.
Cool Che-Stallman T-Shirt.
Cool Che-Stallman T-Shirt.
A lot of confusion has been created because people do not understand that BSD and GPL target different audiences.
BSD is targeted at developers, the people that write code and may (or may not) share it with others. The goal of BSD is to make the code available to other developers with a minimum of legal hassle.
GPL is targeted at users, the people that will actually be using the software. The goal of the GPL is to make sure that users never get "locked out" of their own computer by some piece of closed software.
As a user I don't care that the developer of my software used existing (BSD) code to make his own life easier.
As a user I do care whether I will be able to access my data in the future and if I'm able to fix problems if they might arise. GPL tries to warrant that.
GPL is for users that demand freedom,
BSD is for developers that don't want to be bothered with non-technical issues.