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
When I'm about to write a short algorithm, I first check in the base class library I'm using whether the algorithm is implemented in it. If not, I often do a quick google search to see if someone has done it before (which is the case, 19 times out of 20).
Most of the time, I find the exact code I need. Sometimes it's clear what license applies to the source code, sometimes not. It may be GPL, LGPL, BSD or whatever. Sometimes people have posted a code snippet on some random forum which solves my problem.
It's clear to me that I can't reuse the code (copy/paste it into my code) without caring about the license if the code is in some way substantial. What is not clear to me is whether I can copy a code snippet containing 5 lines or so without doing a license violation.
Can I copy/paste a 5-line code snippet without caring about the license? What about one-liner? What about 10 lines? Where do I draw the line (no pun intended)?
My second problem is that if I have found a 10-line code snippet which does exactly what I need, but feel that I cannot copy it because it's GPL-licensed and my software isn't, I have already memorized how to implement it so when I go around implementing the same functionality, my code is almost identical to the GPL licensed code I saw a few minutes ago. (In other words, the code was copied to my brain and my brain after that copied it into my source code).
Edit: I'm located in Sweden. It makes me even more confused that this is country-dependent. What if I re-use a piece of code (in a manner which is legal where I live) and I sell this source code to a company in a country where the re-use of code would be illegal.
I am not a lawyer - but i've recently been involved in looking at issues like this. Copying and pasting code from blogs can certainly be considered copyright infringement unless the blog states the license that the code is under and how it can be reused.
I'd recommend using sample code like this only to give you the general process/idea for a solution - then reimplement the idea from your own head and in your own style.
As also suggested, mailing for permission is another alternative. Most people blogging code are open to having it reused.
On the first problem: silly as that law may be, technically copyright applies to any expression, and applies without requiring the author of the expression to assert it explicitly; if there is no license, you might in theory be liable for copyright violation even for small snippets. Possible defenses are based on fair use, but (again, in theory) you might end up in court to defend yourself with that (your fair use claim does not stop the copyright holder from suing -- nothing does, except common sense -- but the judge might decide in your favor if he or she decides the use is indeed fair).
Your second problem hinges on whether your code is a derivative work of the snippet, another thorny concept which mingles with the "fair use" issue. Again, the only definitive answer is the one a judge gives in the specific case ("definitive" unless overruled by an appeals court, actually;-).
Remember, most lawmakers are lawyers by training: sometimes one may wonder if they make the laws subtle and difficult just in order to ensure lawyers will always have plenty of jobs;-).
It largly depends on country. In some countries programs are threated as pices of literature so small amount of 'quote' is allowed as a fair use.
Unfortunatly you have to state which country you live in and check what's the local copyright law. In most cases cheaper solution is mailing author for permission (especially if it is open source project).
Copyright law (as in the Berne Convention) protects even small pieces of writing to some extent, so you'd have to consult somebody knowledgeable in the law where you live. There may be something available locally in a library, or you could consult a lawyer.
As far as what happens when you do something legal in Sweden and send it to me in the US where it might be illegal, I don't really know. I think I'd be the one in legal trouble, although there's the Dmitri Sklyarov case to worry about (he did something legal in Russia, came to the US, and was arrested under legal circumstances I don't really understand). Again, consult a lawyer.
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 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 7 years ago.
Improve this question
I've been holding off on releasing a library I wrote because it is the first library which I'll be releasing publicly. Here are my concerns:
The library isn't complete it is in a very usable state, I'd say it is version 0.3, however it still lacks a number of features which I would like to at some point implement, and control how they're implemented (meaning not merging someones implementation).
I'm fearful of criticism, I know there are a few things which should be reorganized/refactored, but I wrote the initial class quickly to be functional for another project I am working on.
So when is the best time to release? Should I just throw it up on github and work on the issues post-release? Or should I wait until I refactor and feel completely comfortable with what I have written?
Most classes/libraries I see are always very elegantly written, however I have not seen any in very early release stages, are a lot of classes fairly sloppy upon initial release?
Release early, release often.
Criticism is a good thing as long as its constructive. Ignore the haters, pay attention to the folks filing bug reports and commenting.
The internal structure of the code matters, but it matters more if it works for its intended purpose. In general, refactoring will change how code works internally but will not affect how it is used. Same inputs and outputs.
You need to get something half-way
useful first, and then others will say
"hey, that almost works for me", and
they'll get involved in the project.
Linus Torvalds
Linux Times (2004-10-25).
It depends on why you are doing this. If it's to provide something useful and it's useful and has benefits that no other library has, then go for it. Just list the status and what's coming next.
If you are doing this to point to on a resume, get it in good shape (the code, not necessarily feature complete). Imagine a future employer poking around the code to see what it looks like, not downloading and running the code.
Whether you release the code in an incomplete state or not, it's always worthwhile having enough documentation to allow users to understand how to use the library.... even if it's only API docs. Make sure that anything incomplete is tagged as TO DO - it helps to maintain a target list of tasks to complete, and lets users know that the feature/method/whatever hasn't been forgotten.
Providing a set of code style/standard documents (perhaps with architectural notes on class relationships) allows other developers to contribute more readily, and in a manner that enhances the library rather than making it a hotch-potch of spaghetti code. It's never easy releasing a library, then having to refactor, while maintaining backward compatibility for users who have already taken up and are using that library in a production setting.
EDIT
Don't be afraid of criticism... it goes with the territory.
Some critcism can be constructive (take heed of that).
There'll be plenty of other people who criticise your code (for whatever their reason) without being constructive, or who just denegrate your work. The difference is, you've produced the goods, they probably haven't ever contributed to any OS product/library.
Users expect you to fix their problems immediately, or to write their code for them to use your library, or simply say "it doesn't work" without any explanation of what they mean. You have to learn to live with that 24x7x365.
But just once in a while, somebody will thank you for saving them hours of work, or for providing something useful... and suddenly all the stress and hassle feels worthwhile.
I read a document by Joshua Bloch, a pricipal software engineer at Google that talked a lot about the best type of API design. Basically, once you release it, it is more or less set. He says
Public APIs are forever - one chance to get it right
You can check out the slides here. It's definitely worth reading. I have a PDF of it as well; let me know if you need it.
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 7 years ago.
Improve this question
I work at a company where the rule basically is (as I understand it) that you cannot use any code unless (a) you write the code yourself or (b) there is some explicit indemnification clause guarding your use of any other code (like open source code). I am finding this making my coding difficult.
For example, coding samples in books are pretty much use "as-is". Microsoft SDK Code Samples are use "as-is". Blog posts about coding are use "as-is". There are several sites out there with code samples (including SO) that are use at your own risk. No warranties implied or indemnification against intellectual property lawsuits, blah, blah, etc.
Basically, I'm confined to using Asp.Net and the .Net Framework and nothing else and to bar my eyes from accidentally picking something up that I haven't created (ok...that may be my anal interpretation of the rule ;-).
I find this difficult because a big part of learning to code I think is reading other code. Reading blogs that have code, reading books that have code, looking at coding samples, using code from SDK samples etc. Also, I would think it is safe to use code that people have shown to be a good solution or pattern for something and freely put up for others to use. I'm not about to think that I can code everything myself. I definitely have to stand on the coding shoulders of others to reach certain heights.
It could be that I don't understand licensing very well either. From the companie's perspective (I suppose) they don't want to incur any risk of beind sued for IP infringement.
My thought is that you have to weigh risks. Taking a coding snippet from a book is low risk. Incorporating code from an open source library could be high-risk. I say make decisions based on how much risk you are willing to take.
Has anybody had experience working in a situation like this or similar to this? Is this a rare thing or is it common in some sectors? Are there others in the same position like me out there?
Any insight or guidance would be appreciated! Thanks!
Edit:
Thanks for the responses! To clear up some things: I'm not advocating stealing code. I'm talking about code that has some kind of public license that allows it to be used in its defined legal way. The key is there is no indemnification in public licenses in using the code. That means it you use it at your own legal risk (and other risk). If someone sues an open source project that you used code from, you could be roped into the lawsuit as well because you are using the code even though it had a public license.
In 2005, Microsoft was using indemnification to compete against open source venders by promising it's partners that Microsoft would protect them against IP lawsuits. http://www.microsoft.com/presspass/press/2005/jun05/06-22PartnerIndemnificationPR.mspx
So, even if the risk of being sued for IP infringement may be extremely low, it is a non-zero probability. Thus, I can't use any of it. Even if it has a public license of some sort. :-(
The "risk of beind sued for IP infringement" isn't really the right way to think about it. This isn't a "risk" thing.
Either
You have a license and can use the source. There's no risk. You have the license. There can't be a lawsuit.
Or
You don't have a license and you're in violation. Effectively, you will be sued. There's no risk here, either. You're in violation of someone's copyrights (or worse).
Companies are averse to Open Source for a variety of strange reasons. Risk of lawsuit is not one of them.
Things I've heard.
What if it has a virus?
What if it doesn't work as advertised?
What if it "crashes" something? Who do we sue?
None of these are "risk" items. They're "due diligence" items. And mostly, they're easy to address: pick products with enough users that someone else vets the code before you; QA open source as if one of your own people typed it in. Except for one.
This leads us to the real reason. [Hint: It's not "risk of lawsuit".]
There's no one to sue when you didn't perform due diligence on open source.
Most shops don't have real solid configuration management or QA policies (the kind that would stand up in court as best practices). Until they have these things in place, they don't dare think about introducing open source for which you really need solid QA and configuration management.
I think what your company is really worried about is you directly copying large segments of code for which there may be licensing issues, presenting a legal problem to the company if they are caught using it. However, you may read blogs or other non-licensed code and discover a solution which works for the particular problem you are working on. In that case, you would be better off rewriting the code (that is, look at the solution and reproduce it) as opposed to just copying the code and making modifications to it. At my company, that is what they generally recommend for using non-proprietary code.
As well, for small amounts of code (e.g. a standard implementation of a cache) where everyone implements this the same way, every time, your company is unlikely to be afraid of using outside code, as long as you are sure to test it carefully.
By "indemnification", I assume they mean assurance that the code is free of copyright or patent or maybe trade secret encumbrance that they don't know about up front, or that somebody's willing to compensate them if something like that turns up. I've never been in a company that worried about this, nor have I heard of one before.
It's not clear what you actually want here, other than sympathy (and I do have sympathy for people trapped in corporate foolishness). It sounds like the policy is quite rigid, if you're worried about sample code in books. This is a bad policy, and will hinder you, but I don't know what you can do about it. Unlike Joel's blog post on getting things done as a grunt, it sounds like you can't just start doing thing intelligently without being in clear violation of corporate policy.
Not knowing your situation, my suggestion would be to look for another job. This one will definitely stifle your professional growth, and a company with that policy is unlikely to be reasonable about it.
(It would be nice if you could assure them there was no danger, but that's not true. People have lied about copyrights, although open source projects tend not to, and only a fool would claim definitely that a large chunk of code did not infringe on any patents in the US; even if it was written a year before software patents were first awarded, that would be merely good grounds for a court fight, rather than avoiding a court fight. GPLed software is actually better than BSD software, since it requires some patent licensing downstream, but it can't deal with third-party patents. Of course, if they're that worried about being sued, writing in-house software is no solution. That can infringe on patents.)
You could rename the variables and how would they find out? Do they check every line of code ? Universities tell you that all the time, not to copy code without referencing. Why don't you try coding something and useing parts of code you find in the Internet?
Generally you will use more from communities like stack overflow or blogs than from open source projects.
Finally since the code has no warranties, its at your own risk.. well the is the same case if you came up with the code by yourself: its at your own risk.
Hope that helps... and good luck.
It could be that I don't understand licensing very well either. From the companie's perspective (I suppose) they don't want to incur any risk of beind sued for IP infringement.
My thought is that you have to weigh risks. Taking a coding snippet from a book is low risk. Incorporating code from an open source library could be high-risk. I say make decisions based on how much risk you are willing to take.
I'm not sure if I understood correctly. If you are saying that license infringement is fine when you don't get caught, I will have to disagree with you.
You can learn by reading code without breaking laws or getting fired. Just don't copy the code to your company's code base if the license doesn't allow it.
If you're not aware of the "clean room" concept, then there's always that approach. Have a friend look at some open source code and get them to tell you how they think it works. Diagram it out, and then code it yourself.
If it worked for IBM, right?
Keep in mind that not all Open Source is GPL. Your company can copy as much BSD-licensed code as they like. BSD-licensed code has made it into OS X (that's probably my biggest understatement of today) and to a lesser extent Windows NT.
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.