Related
I recently contributed some code to an open source library/tool just before I realized that I'd like to re-write this project myself (different programming language and design choices). However, some aspects of the project are just like I would have done them myself or are simply worth "copying". Even if I tried really hard to forget about the original code -- most class names, constants and other stuff just are naturally named the same. The original project's license is AGPL.
Can I use a different license (e.g. MIT)? Which ones?
Will I have to mention the original project somewhere?
If so, where? And will I ever be allowed to remove the notice (maybe after the two projects have truly diverged after a few years of development)?
I am not a lawyer and this is probably not the correct venue for soliciting legal advice.
However, this is my take, as one FOSS contributor to another.
Generally speaking when you contribute to open source projects, you retain the copyright over the code that you wrote, and you release it under a license that permits everyone to use modify and distribute it.
Thus, you retain the right to relicense code that you so contributed under MIT or another license. That doesn't count as "stealing" the code and erasing the GPL license -- you were the original source and you retain the right to release what was originally yours again under a different license.
In some projects, the leaders may request that people DO transfer copyright, although its pretty rare I think. You should check the licensing statement to be sure. Unless there is something in writing somewhere saying that you explicitly agree to transfer copyright to them, then most likely you retained it.
You do not have the right to relicense other peoples work though. In cases where you modified someone elses code, contributing some changes to their class or something, you probably become joint owners, and at least I would not feel comfortable copying the part that they made and relicensing it without permission.
That's just the text of the code though. If you want to rewrite another program from scratch, using a similar high level plan but different execution, I don't think copyright will encumber you. Intellectual property law can still encumber you if some technique or method in the code is covered by a software patent. But it doesn't sound like that's the case here.
To avoid legal issues, sometimes companies / groups of people will use "clean room design" (https://en.wikipedia.org/wiki/Clean_room_design). But iiuc this is just done as a precaution to unambiguously head off any possible lawsuit -- the law does not require that you use such techniques just because you once looked at GPL code, iiuc.
For an example of this playing out, you can look at the history of the MinGW cross compiler project, and the mingw-w64 spin-off of it, which originally began because a private company wanted a version of mingw which supported 64-bit processors and other things, and so used clean room design to reverse engineer the project. The result of this was eventually made fully open source, but was not accepted back into the original mingw project and so there are now two projects. (Hope that this is a fair and impartial summary of the history.)
https://en.wikipedia.org/wiki/MinGW#History
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.
We have a number of AS/Flex components that we've built over time and improved upon. They've been turned into components so they can be reused in different projects and save us time. So you can think of them as part of an in-house framework of sorts.
We're now realizing that it doesn't make sense to release the source code for these components to the various clients as part of the project, because technically this code isn't really owned by the clients.
So my question
When a client comes to you, how do you explain to them that you can't give them the full source code for those components. The client doesn't understand the difference, he just expects you to give them all the code for the site that he paid you to do. He doesn't understand that this code has taken you a lot longer to write than what he's paying for his site. But since he doesn't understand, he would get turned off and thinks you're ripping him off or something.
How do you handle this situation? What do you tell clients upfront? Do you advertise it on your site from the very beginning? How do you handle their objections so they still hire you?
As a side question, how often do you give AS and Flex source code to your clients? In the case when the code doesn't have any in-house components that you reuse in several projects, and in the case when it does have in-house components.
I'd also like to hear from people who've worked at creative agencies since they're most likely have run into that issue already.
I'd explain to my client how the world works. I'd use examples, analogies and metaphors.
This isn't a software-development issue, this applies to all products. Some things are sold as black-box, and some things are sold as a clear-box containing black-boxes inside it.
Lets say you wish to buy a house. You pay the engineer and the architect for their work, and you gain the documents they produce. These documents contain information that relies on other pieces of information, which you do not gain. For example, the engineer may use huge steel bars in his plans. The engineer's specifications determine the qualities that each steel bar must have, but they do not specify how the steel bars are created. Buying house plans doesn't buy you the plans for creating the house's building blocks.
With softwre it is pretty much the same: you don't get the source code for the .NET framework when you buy a .NET application "with sourcecode included". What you do get is the .NET documentation, specifying how to work with the framework (and not specifying how the framework does what it does).
The amount of examples is actually endless, because - as stated above - this is the way the world works.
Build your own analogies to fit your scenario. Explain to your customer where the infrastructure ends and his owned solution begins.
quoo is right about the need to specify these in the contract. The contract is the legal backbone of the deal. But i'd like to emphasise the fact that pointing at the contract should be a last resort. If you can give your client a reasonable explanation such that lets the client understand why things are the way they are, you won't need to wave the contract (which speficies only the way things are, without the motivation, explanation, etc.).
I'm not a business person, but generally these things are specified in the contract. If your contract stipulates that you provide the client with the source code at the end of the project, then at the very least, you should be providing them with swcs of your components so they can recompile the code if necessary. If you don't want to share your code with the client, then that too is something that you'll need to specify up front.
Just explain that you can not provide the source for external libraries that you used on his project to make the bid cheaper for him. He would not expect the source from a 3rd party vendor that you used in his project, just try to explain this is the exact same situation.
Intellectual property issues should be covered upfront as part of the contract. I'm not a lawyer but common practise is to specify:
Which components are provided by third parties and refer to their licensing terms
Which code will be produced as part of the contract.
Whether you license or sell various intellectual property rights.
Licensing terms.
Intellectual Property laws` are complex and diverse, they differ from country to country. Depending where you're and where your customer is the licensing terms might need to change. As an example, reverse engineering viewed differently in different jurisdictions.
Apart from third-party components and software bits you don't want to sell, nor give an exclusive license for you'd probably want to be able to exhibit and distribute the works as part of your company portfolio. This latter activity would also need to be covered within the contract.
Having a well written contract prepared up front will save a lot of misunderstanding and unnecessary negotiations. You'd probably need just one template you could use for all your customers. So my advice really is "talk to a lawyer".
Your contract should make clear that components developed by you are licensed to the client for use as part of the project and only the project(s) you did for them. Of course, you'll need to determine the exact language for yourself and the situation, but if you're repeatedly using these components in your projects, you really ought to have some sort of boilerplate for just this situation.
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 question consists of multiple points that are inherently related, I apologize for that. I tried splitting it up a little more, but I would keep repeating myself.
What exactly is required to apply an open source license to a code base that is my Intellectual Property?
A lot of Open Source projects include a full copy of the license somewhere in a root directory but do also have some sort of file header including a license description, disclaimer and a copyright notice. Is that really necessary or does it depend on the license type?
If someone else contributes changes to this file, does he need to be named in the copyright notice too?
Disclaimer
I am not a lawyer, so you should really consult with one to get absolutely correct answers here.
To the best of my knowledge...
Whenever you author something, whether it be code or anything else, you automatically become the copyright owner of that work (unless you've signed an agreement whereby it is "work for hire").
As the copyright owner, you can apply whatever license you like. The fact is that, if you don't give out a license, then no one has any right to use, copy, modify, distribute, etc. your coyrighted work. So, users need your license to have permission to use the project (if you don't give a license, it cannot, contrary to popular belief, be presumed public domain). So, you don't need to worry about people ignoring the license... if they can't point to a license where you grant them rights to use your software, as the copyright owner, you can sue them for using your copyrighted work without your express permission to do so.
It is typical in open source projects to place the license in a file named "LICENSE" or "COPYING" in the top-level directory of the project. I suggest that you stick to this convention, since that is where people will look for the license. It is also good to indicate what the license is on the project's website, so that people don't have to download your whole project before they know what the license agreement is.
It is not necessary to include a full copy of the license in each source code file, although this is fairly common practice. Keep in mind, though, that putting a full copy of the license (or at least some indication of copyright ownership and the name of the license, if it is a well-known license) in any header files that you install will avoid any confusion as to where the header files originated, so it is reasonable to do that.
If you own the project and others contribute in a fashion similar to "work for hire", then it is not necessary to name the contributors. However, you should make it explicit (and get a permanent record of an agreement from contributors) that you will remain the sole copyright owner of the project, despite contributions made. Otherwise, the contributors do have copyright ownership over the files/code that they contributed.
One last thing, not related to the question... I highly recommend that you avoid GPL and LGPL, and go for a more permissive license (e.g. MIT, New BSD, Simplified BSD), as the former will limit the adoptability of your code, and projects with more liberal licenses, if they do become adopted in the industry, have the potential to be backed by the industry (e.g. the Apache Foundation has strong industry support, because, unlike GNU/FSF which mistakenly views open source and closed source as enemies, sees them as collaborators, and so uses licenses that allow their projects to be widely adopted by the industry world).
Disclaimer: IANAL. That said, here are some random thoughts on the topic:
The term "Intellectual Property" bundles together many kinds of law: patent, copyright, trademark, and trade secrets, among others. Applying a license to a work you create will affect how your work can be used. Because each license allows for different uses of your code, how you apply the license is usually specific to which license you choose. For example, information about how to license your code under the Apache 2.0 license can be found at http://www.apache.org/licenses/. Note that projects managed by the Apache Software Foundation also require each contributor to grant the ASF copyright for the work. Granting of copyright is separate from the license.
I'd recommend reading Van Lindberg's "Intellectual Property and Open Source" to learn some terminology, and if you have significant commercial interests related to the code, spend a few hours with a lawyer.
Disclaimer: I am not a lawyer, the below is simply my understanding of OSS licensing. If I'm wrong, I'd appreciate any corrections.
Clearly state (on your project website, in source code, documentation, splash screen, about dialog, etc.) that the project is licensed under whichever license you select.
Considering the nature of open source, if a portion of your project is used in a different project owned by someone else (e.g. some useful utility class), having the "basics" of the license as part of your source code's header text makes it clear which license governs the use of that specific source file, and who owns the copyright on that portion of code in the project as a whole.
Yes, unless they have supplied you with documentation stating that they have transferred copyright to you (I believe some larger projects require contributors to do this?).
For an example of applying an OSS license to a project, see http://www.gnu.org/licenses/gpl-howto.html
A license is simply the rules you expect others to abide by if they do anything (use it, modify it, post it, make fun of it, whatever) with your code.
a) You can put what you want, but to be taken seriously, you may use a license that is already nicely written and accepted ... check opensource dot org /licenses/category for a (loong) list
b) To decide which type of license, check out this recent aricle: http://www.itbusinessedge.com/cm/community/features/guestopinions/blog/ringing-in-the-new-year-with-clean-intellectual-property/?cs=38892&page=1 . Common ones are GPL V2, LGPL, Apache, New BSD- check out the summary matrix on Page 2 of the article
c) make sure your software doesn't include code from other open source or 3rd party, otherwise you'll be claiming theirs as yours- not a good idea! There are tools you can use on trial basis to scan your code.
d) put the text of the license in a License.txt or Copyright.txt file in the folder. Also add a simple (or complex, if you wish) header to the source files as Kimvais mentions in the previous post.
Good luck.
Short non-lawyer answer;
Nothing except making it clear to anyone that you, the sole author of the code, license the code under whatever terms.
It is advisable to have the license file in the root directory. I would personally add in the "top comments" of all files the line Copyright 2010 <Your Name>. Released under <license name> in <Your country>. The last part is so that you can claim that the license was never meant to be interpreted under any other law than your local (so you can get a competent lawyer in your home country in the event that everything goes wrong)
I would say that this depends on the license you choose
For further info, read this book - or consult a lawyer with experience of software licenses.
Closed. This question is off-topic. It is not currently accepting answers.
Closed 11 years ago.
Locked. This question and its answers are locked because the question is off-topic but has historical significance. It is not currently accepting new answers or interactions.
Today I had a bad surprise learning about some implications of the GPL license, mainly that I couldn't use it as freely as I thought.
Now I know.
What else should I know, and more widely, what should every developer know about legal things like that?
You can separate employees, freelancers, open source projects contributors (etc.) or give a more broad answer.
Twelve Legal Considerations for Software Development
Software is copyrighted if it is made available to the general public. It is no longer necessary to put a copyright notice on the application or in the source code. The owner of the copyright is the author(s) or company paying the author(s).
The copyright of software can be assigned by the owner of the copyright, or it can be retained by the owner and the software can be licensed to the user or users by the owner.
Libraries used in development probably have restrictions in their use and distribution. GPL does not make a library public domain, nor does the fact that the library comes with a development platform. You should read and understand the license before you distribute your application. Some libraries require royalty payments, although this has become less common in recent years.
Software patent lawsuits are crap shoots. You should not, of course, knowingly violate a software patent. However, there is a small but real chance some company will sue you for violating their patent. This may happen even if you develop your software independently, you never heard of the patent, and the patent covers a technique that is intuitively obvious and almost completely unrelated to your software. There is not a lot you can do to avoid this, given the current USPTO policies, other than buy insurance. The good news is that patent trolls generally sue large companies with lots of money.
If you use an employee or freelancer to develop software, you should make it clear, in writing, who owns the copyright to the application, including the source code. Some freelancers and contract development companies consider the source code their own property, leaving the company dependent on the original developer(s). This is legal if it's in the development agreement.
If you have an employee who develops software "off the clock," you should make it clear who owns that software, and what kind of software the employee should be able to write and distribute outside of the company.
If you are an employee or freelancer developing software, you should make it clear who will own the copyright to your application, before you begin development. Also, you should know or clarify who owns software you write on your own time. Some companies have clauses in employment agreements claiming ownership to any software written by a developer during the period of employment, whether at home or at work. Many companies have non-compete clauses in employment agreements that restrict the software an employee can produce for distribution outside the company. Sometimes these restrictions are pretty broad.
A trademark is a name or symbol, not the software itself. If you distribute software, you should (a) make sure your application name and "mark" or design of the name is not "confusingly similar" with other applications, and (b) register your trademark. Date of first use is important in resolving conflicts, so you should document when the application is first used in commerce.
When you name an application, check for registered trademarks, but also check Google. An application with first use of the name may be able to take your name and trademark after your application is successful, even if they have not registered the trademark and you have.
When you use or sign a contract or agreement, make sure both parties understand it. In an employment agreement, mentioning any potentially sensitive areas up front can prevent a lot of problems later. In a development agreement, if both parties know who owns the source code, or who is responsible for upgrades, or who is responsible for maintenance, etc., going into the development project, then there is much less likelihood of a lawsuit after the application has been completed. In a distribution agreement, make sure the distributor understands the responsibilities and term of the agreement.
Every non-trivial application has bugs (or "design considerations" :-)). Any user agreement or distribution agreement should make it clear that you are not responsible for bug-free software, and you cannot be expected to fix all bugs. Make it clear that changes, fixes, and upgrades are made at the option (or best efforts) of the developer, and make it clear who pays for fixes and upgrades.
Even after you consult a lawyer about software development and distribution agreements, you should read agreements from other software companies and see what their lawyers came up with.
I am not a lawyer, and this is not legal advice.
When in doubt, contact a lawyer.
I'm no lawyer but over time I have gathered a few rules of thumb from legal people that you can use to save time:
GPL license is 'copy-left' or 'viral'. It means that any code that you write that depends on a GPL component must also be released under GPL. A good rule of thumb is that if you need a GPL component to compile your software, your software must be released under a GPL license.
You are not obliged to make your source available if you're not distributing your software. For example, if you run the software for internal purposes or on a web server you do not need to release the source. That is why Google doesn't need to release their software that use GPL libraries. It was a key contention point in GPL v3.
LGPL (Library or Lesser GPL) only requires you to GPL your own source code if you incorporate the LGPL-ed library in such a way that it becomes irreplaceable. Your own software do not need to be GPL if you only 'use' the library. Including header files and linking against a .dll/.so of the library is one of the ways you can 'use' LGPL-ed code without any obligations, except for the proper copyright notice.
BSD License (the Apache License is very similar) allows you to create commercial extensions of that use the open source component. That is why Apple chose FreeBSD over Linux as the kernel for OSX.
MPL is very commercial friendly because Netscape thought that they might make some money out of Mozilla at the time the license was written.
It often helps to contact the maintainer of the Open Source project. They are in the best position to advice you about the original intention of the license as well as their own views on open source. Sometimes maintainers are willing to release software under multiple licenses to help you out. Often they are not. Depends on the person who owns the copyright.
The KDE project has a handy matrix
I think Legal Guide to Web & Software Development by Stephen Fishman Attorney is what you're looking for.
Review
An amazing book! Answers nearly
every legal question you can imagine
and some you would have never thought
of. -- John Dvorak, PC Magazine
Covers every imaginable detail
important to such a rapidly growing
and intangible medium. -- Entrepreneur
This book passes my own personal test
for legal guides --with higher marks
than any other legal guide. -- Jeff
Duntemann, Editor, PC Techniques
Magazine
Product Description
Protect your rights, and your hard work!
The laws covering website and software
development are complex and confusing,
but if you don't untangle them, it
could cost you thousands of dollars in
attorneys' fees and lawsuits.
Fortunately, Legal Guide to Web &
Software Development decodes this
complex area of the law, thoroughly
and in reader-friendly English. It
also provides contracts, agreements
and legal forms on CD-ROM, with
step-by-step instructions for filling
them out, so you can protect your
software and website without paying a
lawyer's ransom.
Use Legal Guide to Web & Software
Development to learn:
what kind of legal protection you need
the strengths and limitations of each type of protection
how to avoid infringement
which provisions you need when drafting an agreement
how to obtain permission to use other people's materials
You'll find complete, step-by-step
instructions to draft:
employment agreements
contractor and consultant agreements
development agreements
license agreements
The 5th edition of Legal Guide to Web
& Software Development is completely
updated to provide the latest case law
and statutory revisions.
Some other suggestions :
Working for Yourself: Law & Taxes for Independent Contractors, Freelancers & Consultants (Same author).
Consultant & Independent Contractor Agreements (Same author).
Software Licensing Handbook by Jeffrey I. Gordon.
Practical Guide to Software Licensing for Licensees & Licensors by H. Ward Classen.
The Tech Contracts Pocket Guide: Software and Services Agreements for Salespeople, Contract Managers, Business Developers, and Lawyers by David Tollen.
If a freelancer or contractor: make sure you have good liability insurance and know what's covered under it.
For instance, mine doesn't cover liability for mistakes made in code that might expose credit card numbers. So I don't touch that stuff any more!
For employees : we should be able to give a first round of advice to your clients -- like can they/we use the component we want, in their application ?
For freelancers : we must be able to give strong advice to your clients ; and choose which components we can use for the applications we develop for them.
You course, your word is not as good as the advices a lawyer can get you ; but you can already help for a first round ; for instance, to say "we definitly can't use this because it would mean..."
In the end, the lawyer will know much about corner cases -- but if you can help a bit...
For OSS contributors : knowing some differences between free licences can matter if you care what people can do with your code (redistribute ? modify ? use it in commercial application ? use it in proprietary application ? )
One answer has asserted that the law is not like code. I disagree.
In the early days, IBM paid programmers by the instruction. (Someone I knew said he worked with a programmer who got rich this way. Apparently the guy didn't know how to use the machine's index register; he wrote a memory-zero routine that manually stored zero in each memory address.)
There was also a time (long ago) when lawyers were paid by the word. This helped to popularise practices such as addressing people as "the most highly esteemed such-and-such" and other verbosities.
I just read an answer on SO that said VB.NET 2008 still allows line numbers. You can still run pure DOS on a modern PC. And there is much truth to the joke that all COBOL programs are decended from a common ancestor by incremental changes. Backwards-compatibility, and "historical reasons", are rife in our field.
This is comparable to the realm of law. There are laws which make small (or big) changes to other laws. You've got a kind of dependency-hell. There are some ridiculous historical laws (in Hobart, Tasmania, it's illegal for a man to wear a woman's dress after sunset - because once upon a time, convicts would dress up as women and mug people) that nobody would dream of enforcing, just as there are some historical features in software that nobody uses anymore.
Laws often have unintended consequeuences (bugs!), get used in creative ways (hacks!), contain loopholes (security vulnerabilities!), some of which are intentional (backdoors!), get modified (patches!) or overturned (uninstallation!).
Yes, laws (unlike code) are subject to interpretation. But I think this is rather like code maintenance. It helps to adjust laws to new social norms.
To answer the question directly: every developer should know that law is rather like a ridiculously enormous software project that has been in development for hundreds of years. (Actually, each country has its own project, and they solve problems in different ways.) In theory, after reading a licence you will know what you can and can't do with your code. But if a competent programmer can't spot all the bugs in his code just by reading it, then what chance does a non-lawyer have of analysing the corner cases and grey areas of a legal document?
Like with software source code, you can usually get the gist of a legal document by reading it, but if you need to know something specific, ask a professional.
NOLO (I don't work for them) publishes a good set of legal how to books for the layman.
http://www.nolo.com/products/a-legal-guide-to-web-&-software-development-SFT.html
I would answer this in the same way that I would answer "what should every lawyer know about programming?" That is to say, know that there's no way you can possibly know the in-depth field well enough to do more than the simplest of things. Get an expert.
You should know the basic rights and obligations of the license you are going to use. It's not that hard, and even if there are plenty of them, you need to read carefully only those you are going to use or touch. Just read them, in most cases they are quite clear.
Anything else you could need, well, that depends. Patenting ? Trademarks ? If you need these things, chances are that you are in a company and have a legal department to do this for you.
I would always assume that the developers of a project want any software using their work to be released under the exact same licence. Read their FAQs and legal pages for more information and don't hesitate to contact the developers/maintainers if you are still unsure.
If you want help understanding the details of a licence agreement, talk to a lawyer.
Don't work in a country that has more lawyers than developers.
An extremely large percentage of all (U.S.) software patents are bogus, but you can't pay or wait for them to be invalidated.
If you want to use/develop open source software, use an existing license and don't modify it. Don't go near the borders of what the license is supposed to mean.
The name of a good IP lawyer.
6.If you have an employee who develops software "off the clock," you should make it clear who owns > that software, and what kind of software the employee should be able to write and distribute
outside of the company.
freedom of speech right as stated in most constitutions (esp. if devs make free s/w off-the-clock) can make such terms fail miserably in courts
The law is not like code. It is not a well cast set of steps and rules that can be unambiguously understood.