Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 9 years ago.
Improve this question
I'm a software engineer, not a lawyer, and my university doesn't offer any courses geared toward licensing software. In fact, their law-related courses are lacking (but slowly growing in number). Where can I go to learn about open-source licenses and how to choose them?
There are lots described here:
http://www.gnu.org/licenses/license-list.html#SoftwareLicenses
The decision of which one to use can be political, but should ultimately be determined by your plans/desires for the software. If you want to ensure it is always free then choose GPL or another "Copyleft" license. If you don't mind some commercial use, choose another one that's compatible with that.
I almost always end up usign MIT or BSD (they're equivalent), since it
Is the most liberal license out there. It just says you're not responsible for any kind of trouble, and optionally forces people to include a copyright notice of your original work in derivatives.
It allows closed source derivatives, which is something I see as a good thing: companies sometimes don't have the possibility to do their work under the GPL (they may themselves use products or components from a third party with restricted licenses).
That, and the GNU/GPL bunch are generally extremists when you encounter them in the wild.
This can create endless discussion, but there is one tenet I would hold to whenever deciding what license to use: DON'T CREATE A NEW ONE!!
No matter how persuasive your legal guy's arguments that, because no current license exactly meets your project's unique needs, you should write your own, or even just "slightly modify" an existing one, treat him like a programmer coming to you arguing that he just HAS to use a GOTO statement because nothing else in the language will work.
Other advice:
Choose one which has major usage (see http://freshmeat.net/stats/#license)
See David A. Wheeler's discussion of why to choose a license compatible with the GPL - http://www.dwheeler.com/essays/gpl-compatible.html.
If you are looking for information regarding free and open source licenses a useful comparison chart: http://en.wikipedia.org/wiki/Comparison_of_free_software_licences
You could always just use the best one of all, the WTFPL. I use this on most of my school projects since they aren't that great anyways.
Wikipedia, of course, has basically all the information you would ever need to know. But the hard part is to know where to start. I'd recommend starting off by reading about the Apache License and the GNU GPL, which are two popular sides to the same story, each offering different freedoms to the people associated with the code.
But here it is in a nutshell: Apache License lets anyone do anything with your code, including taking it and using it in a closed source product. It gives whoever is taking the code the freedom to do what they want with it.
The GNU GPL, on the other hand, allows your code only to be used in a project that is also distributed under the GPL. In this case you might write some code and prevent a proprietary company from using your work. Here, you're giving freedom to the code itself that it will always be used for "free" purposes.
I'm slightly surprised to see no mention of the Open Source Initiative as a source of information about which open source licences exist. It probably doesn't do the comparisons, so the other sites are also worth checking.
More pragmatic reasons can also influence your choice of license - if you want to use a GPL library, you must use GPL yourself, or if you intend your software to be part of a larger project then you need to look at their requirements.
I've recently begun investigating the type of licensing to apply to a rather substantial piece of work. The number of choices and the content, restrictions (or not) and limitations of all the open-source licenses is bewildering. I've found a couple good links in the answers posted, but I didn't see anything pointing to the Open Source Initiative's alphabetical list of licenses, so I've included it here.
We had a similar dilemma. At our company we decided invest lots of time on a framework, with the eventual hope of releasing it to the open source community. The business is built using open source tools (apache, php, etc.), it was time to give back. We decided on an LGPL/MPL dual license. That way, we could incorporate fixes/improvements from the community, while still protecting applications (particularly ours) running on top of it from being forced to go open source as well.
Related
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 7 years ago.
Improve this question
I thinking of a good opensource licence to choose for my project. I got a few requirements but I have a hard time choosing a license because a read some different things about some of them.
The project is a Java project that can calculate decompression schemes for scuba diving. I want this project to be opensource because a wrong decompression scheme can be lethal. Therefore feedback on the algorithms and source code is important for me. I don't make my own algorithms but I use various opensource algorithms that I implement in 1 Java library.
My requirements are:
I and other contributers to the project don't want to be responsible for wrong calculated decompression schemes due to bugs in the code, miss use of the code or any other way that resulted in wrong decompression schemes.
The library should be able to use on a website I plan to build without the need to publish the server side code of the website.
It's not allowed to make any profit of the library itself. Even not even the library is changed and republished. However I don't mind if people sell programs the make use of the library.
If people change the code than they should be forced to re publish the library with an opensource licence (Optional requirement).
I hope someone with a bit more knowledge of licenses can help me out.
Well, there are a couple of things I notice right off the bat here.
First off, you talk about needing to be able to do things with your own code. If you are the copyright holder, you can do pretty much anything you damn well please with your own code. The license is for other people, not for you.
Also, disclaiming any responsibility for what the code may do to other folks is pretty much boilerplate with any license.
That being said, I've found in my work I can get by with the use of only 3 different kinds of licenses, depending on my needs.
Full on GPL
Benifits:
Nobody can ever take any of the code propreitary (without coming to me for a relicense). They can still use it and charge people, but since they'd have to license the result GPL, that wouldn't be particularly practical. The reason is that any of their users could give away all the free copies they like.
The sources are avilable for anybody to contribute to, so I might not have to find and fix every damn bug and write every new feature myself.
Drawbacks:
None of the code is usable in a properitary app
I use this typically for stand-alone apps.
GPL with linking exceptions
This is basically what it says; GPL with an exception that meerly linking against (or #including) the code does not render the entire result GPL. Here's an example from the Classpath library.
Benifits:
Nobody can ever take the code itself proprietary.
The code can be used in a proprietary product without making the whole closed-source product open-source. Only the GPL-licensed stuff has to stay GPL.
Drawbacks:
The facility itself can never be expanded into a proprietary facility. Generally a plus in my book, but it does deter some people from using it.
I use this typically for helper facilities and API's .
Public Domain
This means anyone can do anything they like with this code, including making a tiny tweak, slapping their own copyright on it and calling it theirs.
Benifits:
Anybody can feel free to use it however they like.
Drawbacks:
No protection from the code getting "stolen" by a proprietary software seller.
Impossible to do in may jurisdictions (a permissive BSD I understand can be a good alternative there).
I use this when I'm publishing something incomplete that I really want someone else to take over, or when publishing something that is supposed to be a reference implementation for a standard library.
Now in a case like yours what I would do is either:
Use GPL with the linking exceptions for the library. That will allow everyone (including you) to use the library in a proprietary application, but the library itself will always stay Free.
Use GPL, and insist that contributions from others have their copyrights assigned back to you. This allows you full rights to make your own proprietary app using other people's contributions, and doesn't allow anyone else (including those contributors) that same right. Kinda cheesy in my book, and will probably discourage outside contributors. However, only the most successful Free Software projects get any outside contributors anyway. So it may not be that much of a loss.
It came to my attention recently that Bruce Perens (one of the founders of OSI) actually made a blog post a year earlier that made the exact same point. He picked two different licenses than I did for the latter two though. He picked LGPL for the intermediate license, which I think is a mistake on his part. However, he picked the Apache License 2.0 for the latter license, and I think he may have a point on that one. The benefit you get from using Apache over straight Public Domain is that you are better protected from patent lawsuits. That isn't something poor little me really has to worry about, but your company is a different matter entirely.
This impossible. You say you want an open source license that prohibits making money. However, one of the key requirements for being an open source license is not making any restrictions with respect to commercialization.
Ergo, a license like you describe it cannot possibly exist.
And here the standard answer: StackOverflow is a site for programming questions. We are programmers. Your question is a legal question. This means that all answers (including mine) will be, by definition, crap, since we don't know WTF we're talking about.
For legal questions, ask a lawyer.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 7 years ago.
Improve this question
My application is reaching a pretty nice beta/alpha level and I might at some point publish it. I have not decided what software license to use in my application. The application is under construction. I bet this must be a question that every developer thinks about at some point.
My software is more like a library and here are some key factors in my case:
It must be an open-source license.
It must be free for developers to use as a library for their applications.
Developers are allowed to redistribute the source code as part of their applications modified or unmodified.
The library can be used for closed-source software.
I want attribution/credit. A one-line credit in the software Help dialog or somewhere in about section of their website is fine. As long as it is reasonable easy for a 3rd-party to find out what library was used to produce the resulting software.
Forking a new project out of my existing source code should not be allowed. I want people to be able to use it and even modify it, but not clone a new similar product to compete against my existing product.
The license needs to state that I take no responsibility for any damage whatsoever.
Is there such a license? Would those requirements even fit in an open-source license?
Forking a new project out of my existing source code should not be allowed
Above is in conflict with Open Source idea (which allows/encourages forking). More info here: Which open source license has no forking
If you think that you can drop that requirement the best choice is LGPL and additional requirement that people must give you credit (you will have to define what type of attribution/credit do you want per different uses)
As James stated in previous comment:
Forks very rarely happen
It is very hard to fork a (big) project
You can benefit more if there are forks - you can take the good ideas from the fork and leave the bad. That way the better judgement about features/code will eventually win (which is part of the idea of Open Source)
Forking a new project out of my
existing source code should not be
allowed. I want people to be able to
use it and even modify it, but not
clone a new similar product to compete
against my existing product.
Ummm ... This is I have never heard of in a Open Source license, and I don't know of any that have this. How would you even word it? Determining the difference between a fork and someone else who has taken your code and just added a patch would be really hard.
Can you think about this one? Forks very rarely happen, and when they do they aren't always competition. Talent, ideas and even code can flow between the forks freely.
You need to speak to a lawyer, we aren't lawyers and don't know your application.
Prevention of forking with open source licenses is complicated, as James says.
For commercial applications, you may want to look at dual licensing.
As far as I know the LGPL allows forks.
You should be able to find one to suit your needs here:
http://en.wikipedia.org/wiki/Comparison_of_free_software_licenses
More specifically I think the GPU Lesser Public License might suit the needs of your library. Keeping in mind that like (all?) open source licenses, LGPL allows forking.
http://en.wikipedia.org/wiki/GNU_Lesser_General_Public_License
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
I am a web developer, and I don't have enough knowledge about software licenses. I wish to publish some of my works, and I need to select licenses for them. My software product is free of cost, but I have some restrictions on distribution/modification of the code.
It’s free of cost (but donations are acceptable).
The source code is freely available. You can use, customize or edit/remove code (as long as the basic nature of the software is not changed).
You don’t have any permission to change the product name.
There are some libraries and classes which are in a folder called “myname”. You don’t have permission to rename “myname”.
You can contribute any additions or modifications to my project, to the original source repository (the contributor’s name/email/site link will be listed in the credit file).
You can’t remove the original author’s name from the license.
You can put the license file or license code anywhere in the project file or folder.
You can redistribute this code as free or commercial software.
Are all these restrictions valid? Given these restrictions, which license should I use?
My main intention is to make the product more popular with free source code while ensuring the original author is not ignored. The product is open.
Thank you all; the above points are because of my lack of knowledge of license terms.
You can help me to correct or remove some of the above points. What I’m basically looking for is in the paragraph above.
I don't think the following are currently covered by any license I am familiar with:
Don't deviate from the basic nature of the software.
You can use/customize/redistribute as free or commercial, but you can't change the name.
I'd argue that while the product may be free and "source code available", that what you're describing is not "Open Source". Notably, you're not letting people fork and/or repurpose the code, both of which are main features of an Open Source code base.
By retaining copyright, no one can "take your name off" of your code, as they don't possess copyright, but not being able to rename the project, or change the names of folders, that's pretty extreme.
So, I would suggest you think through your motivations behind releasing the code and from where these restrictions originiate.
As others have noted, you have some rather odd requirements:
“Don’t deviate the basic nature of the software.” (Do you specify the “basic nature of the software” in the program itself, and are you going to argue in court over something so vague?)
“You don’t have any permission to change the product name.” (Usually, if anything, the opposite is required: if you change it, you have to change the name, so people don’t think that the modifications represent your work.)
“There are some libraries and classes which are in a folder called ‘myname’: you don't have permission to rename ‘myname’.” (Similar to the first, but more concrete — though I’m not sure what the point of this is.)
Based on these requirements, I think the license which fits most closely with your stated desires is the GNU Free Documentation License. As indicated by the title, it’s almost never used for source code of programs.
It is the only license I know of which allows you to prohibit users from changing or improving specific parts of the work. For example, I think you could say that the folder “myname” is an “invariant section” (note that I am not a lawyer, and this is not legal advice).
It’s not compatible with the GPL, and (the way you’d use it) it’s not DFSG-free. It’s rarely used for software, so distributors and contributors might have trouble understanding how to apply it. In short, you probably wouldn’t be making any friends with this route.
BSD license should cover this. I have chosen it for my open-source stuff too.
As written your requirements don't fit into any specific license out there (that I know of), and since you are not looking to make money, getting a lawyer to draft one would be rather expensive, and fundamentally counter-productive.
I suggest you look at licenses for different open source projects out there and see which one matches closely with what you want, and use that.
To get everything you want you will probably have to write your own license. This is not necessarily in your best interests. You are going to have to make a choice between popularity and control:
If you use an established license, you will have a very wide audience for your work, which will have a chance to become popular.
If you insist on certain restrictions (the name can't be changed) you will keep greater control, but you will lose potential users; because lots of organizations won't look at software with a nonstandard license.
Your requirements are very close to BSD, and not that different from MIT. I recommend you browse the popular licenses blessed by the Open Source Initiative and choose the one you feel is closest to your desires. I've checked your edits, and if you insist that I make a recommendation, for your wishes I recommend the Simplified BSD license. It's a good, popular license that is often used by developers who want their work to be very widely deployed.
If you ask people in a README file not to fork your software and change the name, as a matter of personal preference rather than licensing terms, most people will honor your wishes.
I think you will have a hard time finding an existing license to fit your needs because you seem to require two separate sets of permissions: a MIT-like set of permissions for the source in general, with the exception of a locked-down "myname" folder. You may be better off separating your code into two separate parts, each with a different license. The MIT license seems to fit your conditions for the bulk of the code (except for the "basic nature of the software" statement, I'm not sure what you mean by that). The MIT license requires the copyright statement bearing your name to be retained in all copies of the source, so this would address the concerns you bring up in your first edit. Depending on the particular reasons why you need to add special restrictions for the "myname" folder, you may have to write a custom license (you can take an existing one that's close and simply tweak it) that governs only that folder. Your entire project doesn't have to fall under a single license.
3) You don't have any permission to
change the product name.
You might be asking for problems with this one. If someone takes your code, enhances it, and releases it with the same name then you will have two very different programs out there with the same name. This is very confusing for potential users. Is the the original version? The version that was modified with a German-language interface? The version that has a fix for a specific bug? When they all have the same name, it's difficult to determine. If a user has a bad experience with a particularly buggy (or worse, virus-infected) derivative work, they will be unlikely to use any version of your software because it appears to be the same program as the buggy version.
I get the impression that you are mostly wanting to avoid having your work copied and completely re-branded without any acknowledgment of your involvement. I might suggest that instead of prohibiting name changes, require that derivative works reference your original product name (for example, "ShinyNewProgram - Powered By YourOriginalName"). Many open-source projects trademark their product names and a provision like your #3 would then be a violation of trademark law; the more common solution is to require a new name (to differentiate it from the original) and to require clear attribution of the original work.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
The producing open-source software book is a gold mine of information on starting open-source projects. Yet I am hoping to learn more from the experience of stackoverflow users and was wondering what are the mistakes you made when starting a new open-source project (or difficulties you encountered when attempting to contribute to a new project), and how would you avoid these traps to become a successful project*?
**Successful loosely defined as a project that is used, and attracts active contributors.*
My two biggest mistakes are:
I expect the world to fall in love with my project as soon as I post it anywhere. If I don't get immediate feedback how great I am, I quickly lose interest.
When I get quick feedback, I often don't respond on a timely basis because I have so many projects.
"Eat Your Own Dog Food."
Be your first user. This is good:
to know what you're doing
to motivate yourself
to get early feedback
I think it's nearly impossible to write open source software you're not using yourself.
"Eat Your Own Dog Food" tries to break out of the vicious circle: Nobody uses the software because it is not useable; it is not useable because there is no user feedback. Try to develop something that is useful for you and see if it sticks and gains some traction.
Besides using the software yourself “Release Often, Release Early”. With release I do not mean publishing some source zip somewhere but a real end to end release.
Choosing the wrong license (for different values of 'wrong') is a common pitfall. Two examples:
1.) If you're using a license that does not allow for relicensing under different terms and you accept contributors code, you need to keep in mind that the code suddenly is not yours anymore. This is fine for some hobby project, but might limit your commercial options later. Of course, it also limits other's commercial options too.
An example for this is the GPL. Include contributed code under this license and you're bound to the GPL yourself and can't decide to dual-license later (unless you nail this down for every contributor). Even a simple change of the license to a similar OpenSource license is impossible: See the linux kernel - it's bound to GPL V2 and can't be updated to GPL V3.
2.) If you're using a permissive license (e. g. Apache, MIT, BSD) you need to keep in mind that not only you can go commercial and close the code later, but anybody else can do so too.
Don't get me wrong: I like the GPL, I'm happily contributing to GPL projects and am glad that these projects exist. I also like BSD, Apache, MIT (the permissive ones) and am contributing to projects that others exploit commercially, e.g. through "Enterprise Editions" of the software that I'm getting OpenSource. It's all fair game - you just have to be sure what options you want to have later. None is better, they're just different.
The first pitfall is to start a new project when there are already plenty of existing projects that are planning to do the same thing.
Currently I am starting a blog based on a talk that I have given on the FrOSCon here in germany.
First article: There shall be light – things to keep in mind when starting a project
Maybe this helps. I don't know how long it will take to write the following 19 blog posts.
I'll answer clinton here:
Not so obvious stuff for new users is:
For User focused software:
getting started guide (Get the software to run quickly)
screenshots! Users love screenshots and too few projects provide them
For developer centric software:
getting started guide ("get to code quickly" for example by explaining dependencies, structure, compile and start process)
code of conduct
I'll think a little bit more about it and add it here.
Positively super great documentation is a must.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
The company I'm working for is facing some difficulties and our future is, let's say, uncertain. Over the last years, we have developed a framework to build community apps and social networks. We believe that this initiative should not be totally lost, and that it may be useful for the community, so we decided to open source it.
I have some questions regarding this process:
How to choose the most suitable license knowing that the original authors could still contribute and/or do some consulting ?
What are the necessary modifications we have to do in the codebase ?
Do you have some pointers to some existing docs / books which would cover this wide topic ?
I know that those questions are quite open and that there is no simple answer, but I would like to hear from some people with similar experiences.
Thanks in advance !
For the license, you have to ask what your goals are for the license. Is your goal to build a community of people who contribute code back, and not let anyone else create a proprietary fork of your code? Then the GPL would be a good license to choose. Is your goal to allow you to retain copyright, distribute it as open source, but offer an alternative license for people who want to link it to proprietary software? Again, the GPL might be a good choice, though in this case you'll need to make sure you set up copyright assignments from any other contributors that send changes back to you so that you can re-license their contributions.
It sounds like your code might be server-side software, in which case you may want to look into the AGPL; the AGPL is like the GPL, but also requires people to distribute the source to changes if they run it on their own server (which the GPL doesn't require, as it only ever requires anything when you distribute it).
If you want people to be able to build off of it while writing proprietary software, but still contribue changes back to your software itself, the LGPL is pretty good. If you don't care about proprietary forks, and want something that's simply permissive, then the MIT license is a good choice.
The only modifications that are necessary are those that remove any code you are not legally able to release. If you own the copyright on all of the code, then it should be all good, but be careful of any cryptographic code, and talk to a lawyer if there is any in your program. Export restrictions can be a pain to deal with, though they do have provisions that make the process simpler for open source software.
Beyond the necessary modifications, it is good to make sure your code is easy to build and run on as many systems as possible. For instance, you should check which of your dependencies are required, and which ones can be made optional. Some good documentation on how to build and install your software is also good, as well as all the usual things you want in any software development (not just open source), like an easy to build system, unit and regression tests, etc.
A few other things to think about are:
How will other people get their changes to you? Patches on a mailing list? Patches attached to bug reports? Forks on GitHub?
What revision control system will you use? I generally advocate for a distributed revision control system like Git or Mercurial, but Subversion is also very popular and should do the job.
Make sure you make it obvious how the community is supposed to work; a web page describing how to get the software and how to contribute, pointers to your mailing list or IRC channel or whatever medium you want it to be discussed on. If you are going to have a core group of committers or something, document how the process of choosing committers works.
I could go on listing more and details, but I'd probably be repeating things that have already been said. If you want more information, I'd recommend reading Producing Open Source Software by Karl Fogel.
If you're looking for ways to incorporate the open sourcing of this software into a strategy to make money for your company, Joel Spolsky's take is one of the most clearheaded I've read.
If you only read one book on the subject of open source licenses, then it would be hard to do better than Open Source Licensing by Lawrence Rosen.
We've done the same process last weeks. We choose Mercurial as version control system, which works like a charm. Bitbucket is a hosting company, which provides Open source projects with free hosting. You also need more documentation, because people from outside the world will hopefully join your project - this is something different from explaining things to your collegue next door.
One important thing is also that you have to keep in mind, that you now have an audience which you dont want to annoy. With internal development you often change your API, the database schema or something like that. With open source you have to keep in mind, that there should be compatibility between minor versions and clear migration paths if necessary.