Slashdot Mirror
Can Employer Usurp Copyright On GPL-Derived Work?
An anonymous reader writes "I am a recent graduate, and I've been working on my own on a project that uses GPL-licensed libraries. Later a university department hired me, on a part-time basis, to develop this project into a solution that they needed. The project's size increased over time and soliciting help from the open source community seemed like the obvious thing to do. However, when I suggested this, my boss was not interested, and it was made clear to me that the department's position was that copyright of the whole thing belonged to them. Indeed, by default work created for an employer belongs to the employer, so I may have gotten myself in the same trap discussed here years ago. Even though I want to release my code to the public I don't know whether I have the legal right to do so. I did start the project on my own. And, since no written or verbal agreement was ever made to transfer copyright over to my employer, I question whether they can claim that they now own the extended version of the project. Also, the whole project relies on GPL libraries, and without those libraries it would be useless. Can they still claim copyright and prevent me from publishing the source code even though it is derived from GPL software?" Some early commenters on the submission pointed out that it matters whether the libraries were licensed under the LGPL vs. the GPL.
no GPL violation if they do not distribute. what are your grounds for suggesting this is a GPL violation ?
All the work you did for them belongs to them. However, they may not be legally entitled to use it how they'd like. If it's based on GPL code and they don't want to release the whole thing under the GPL, they'll need to rewrite the sections under the GPL before they can have their way with it.
Let's be clear. You have no rights to do whatever you want with the code you wrote for them.
A lawyer will be able to help you.
What you need to take away from all this is the same simple advice Homer gave Bart. "Never try"
All you gain from trying to make this software GPL is a lot of heartache and lost time. In the worst case, you can lose a lot of money to lawyers and ultimately the whole source base and copyright.
Was it worth it?
Even though I want to release my code to the public I don't know whether I have the legal right to do so.
That sounds like "you need to talk to a lawyer" material.
IANAL, but my guess is that if it's in your contract, you'll probably need to demonstrate that you weren't aware of that at the time you signed the contract in order to keep copyright (or control of licensing) on your work. However, given that they hired you to develop a GPL product, it seems silly that any extended code produced is not also GPL licensed.
Ask me about repetitive DNA
I'd also like to note that I work for a large company that knowingly pays me to do exactly this all day. I write proprietary software using GPL libraries and such all day. We just don't distribute it.
Gah. Every time this kind of story gets posted to Slashdot we go through the same conversations.
You entered into the employment and provided them with the code base, they most likely have a claim to it.
All the work you did for them is work-for-hire, they own it.
There's nothing wrong with using GPL libraries for internal proprietary software.. the GPL is a *distribution* license, you haven't said anything about distribution so I'm assuming they're not distributing it, in which case the GPL is irrelevant.
There's lots and lots of source code in the world, plenty of it is free for you to hack on, move on.
How we know is more important than what we know.
If your project is only used internally, i.e. if it's not distributed, the GPLedness of the libraries you're using plays no role. If you're not distributing, the GPL places no restrictions whatsoever on what you do with the libraries. Now, since you started the project before getting paid to do so, it might be the case that the step where you so to say 'gave' it to the university counts as distribution, and then there would be no alternative to an at-least-GPL-Free license for your project, but that is something you should ask a lawyer about, not slashdot.
Before they can have their way with it, yes - but they can use it internally - just as I can make derived works from GPL code and use them however I want, myself or in my company. What I can't do is distribute it, sell it, etc... but if I base my employers in-house time-tracking system on some GPL code - the company is under no usage restriction whatsoever, and is under no obligation to share those changes with anyone else.
If they do want to distribute the stuff outside their organisation, they'll have to do so under the terms of the GPL - other than that scenario, they can do whatever they want internally.
Well, I'd say that there are multiple issues at hand. First of all, I'm pretty sure you can release the original code that was around before you started the job without any issues. If you were to release the additions and modifications you made after the employment started, that code is rightfully theirs. After all, they hired you to work on the project for them, they didn't contract you to make changes to your open source project.
Location is an issue that might come up with the GPL. Different countries would interpret the GPL differently. Just because it's been tested (more or less) in the states doesn't mean that it's been tested elsewhere. Given the time of your posting, I'm assuming you're somewhere outside of the U.S. and therefore the requirements of the GPL aren't necessarily clear.
I had a similar project at one point. I would never use the GPL as I believe in free software, so I use a modified BSD license. But when my employer decided they didn't want to continue making my code open, I wrote it over (it was only 15,000 lines, so it took a few weekends) and BSD'd it. It's still not as complete as the original, but it's functional enough to be useful to others now.
I recommend that you keep in mind that you work for your employer and if you feel your employer has violated your trust, you're welcome to leave. Additionally, if you violate their trust, they're welcome to release you from your agreement.
While it may be legally OK to release the code as GPL, it doesn't mean that your employer will agree with your decision and may decide that they'd prefer to work with someone who's more attuned to their wants and needs.
He doesn't need to change the license.
1. Alice starts a GPL project.
2. Bob hires Alice to write an extension to the GPL project.
3. During her employ (or before, it doesn't matter) Alice uses some GPL libraries written by Claire.
4. Alice leaves Bob's employ.
FACT 1: Bob owns all the changes Alice made while in his employ.
FACT 2: Alice had no right to distribute changes owned by Bob.
FACT 3: Bob is not obligated to distribute the changes.
FACT 4: As the GPL only relates to distribution, not use, Bob is free to use the software.
FACT 5: If Bob later distributes the changes without placing those changes under the GPL, both Alice and Claire can sue him.
Nothing "automatically" becomes GPL software.
How we know is more important than what we know.
According to the GPL FAQ over at gnu.org, internal corporate use does not count as distribution: http://www.gnu.org/licenses/gpl-faq.html#GPLRequireSourcePostedPublic
This isn't stealing. Almost all programming jobs will contain a clause saying your employer owns any code you write while you are at work there. It sucks sometimes but it is sort of fair depending on how you look at it. The whole notion of working for an employer revolves around you giving up something in exchange for money. In this case it is your freedom and your intellect/creativity/etc.
The issue here is that if your employer does not wish to make your changes public (and comply with the GPL) then these changes need to be removed from the public work...so that the public work can still meet the terms of the GPL.
They can indeed continue to use it in-house provided it is not "distributed" from one party to another.
As correctly pointed out in other posts in this thread, the GPL only comes into play when the work is copied/distributed. You can do whatever you like with GPL code in-house. It is only when you later distribute that work to another party, that you become bound by the terms of the GPL.
Also consider this: Releasing code publicly that your employer owns the copyright to, is actually stealing from your employer.
This seemed like a reasonable sig at the time.
If my understanding is correct (not guaranteed by any means), they would only be in violation if they released the binaries. Any work done before he worked for them is his copyright and he could release that but any work done after his hire is theirs and as long as they keep it in house, there is no violation.
Setting his threshold to 5, Sparky eliminated most of the trolls on /.
This is what it boils down to, and what people often forget or misunderstand about GPL. You can do with GPL code whatever you want internally as long as you don't distribute it. It is a license that specifies how the party someone distributes to has to distribute it when he/she does.
The code OP wrote on his own is on his copyright and he can distribute under the GPL. The extensions he wrote for his employer are owned by the employer (he has the copyright). If he wants to distribute it, the employer has to respect the GPL.
They can claim copyright because they own what you produced at the time you were employed there (usually, may depend on the contract).
Since you are at a university it might be smart to see if there are any regulations or memos that recommend or require that department-developed software becomes open source. I know that some countries, particularly in the EU, see that tax-payed software should become publicly available. Try make some suggestions in this direction.
NB: The message above might reflect my opinion right now, but not necessarily tomorrow or next year.
In Australia, there's a legal precedent saying that code written by an employee is owned by the employer, even if the employment contract doesn't mention it.
IANAL. If you care about this, get one.
Is the project really worth the trouble? Both you and the department failed to take the proper steps when you were hired. If you push the issue, they may fire you. You'd likely be blackballed from ever working for the university again. If the matter goes to court, you might scare off future employers down the line. Companies get very scared at the idea of someone introducing GPL poisoned (their frame of mind, not mine) code into their products without disclosing it.
Unless this is some amazingly cool and important project, it might be worth just taking it as a lesson learned. Don't ever use code that requires a license in your employers' software without documentation (and for something like this, keep an extra copy at home), especially if it's something you wrote. Cover Your Ass (CYA).
Down the line after you leave the university's employment you might go back to your code prior to be hired and release that but it still might be pushing it. You might be legally right but that doesn't mean that you can afford a Pyrrhic victory.
Did you begin the project as a student (prior to being paid), particularly in any way related to a class? If so, some universities attempt to apply IP ownership to students' work.
From my understanding of the GPL, you were fine creating software that relied on GPLed libraries and not GPLing it, provided you didn't release it. The place where it kicks in is when you distribute (say, to the university). At that point, you were obligated to put your code under the GPL. Did you do so and if so, was it formal?
Assuming that there's no student clause, you own the copyright on everything you wrote prior to them hiring you. They most likely own everything after that. For you to have legally distributed the initial code to them, it would have to have been GPLed. If it wasn't formally GPLed, they could try to put you on the hook for using unlicensed software in what you wrote for them.
They could GPL their portion of it and everything would be solved. Or they could eliminate all of the original code and still use the GPL library and be legal so long as they don't distribute it.
Honest question: does distribution internal to an organization count as distribution as described by the GPL? That is, if I have code subject to the GPL, and I distribute it to my employees without allowing them access to the source code, am I violating the GPL?
This question may be easily answered by another read-through of the GPL, but I'm too tired to do that myself right now...
First / correct answer: ask your lawyer. This is a question for lawyers
second, more general useful and helpful but speculative answer. You probably don't mean "distribute it to my employees" you mean "install it on my computers which my employees use". In which case it's not a violation of the GPL. This is because it doesn't count as distribution because it is on your own computer and so you (the company) still really posses it. Full details of this may well vary from one state/country to another.
=~ s,(.*),<sarcasm>$1</sarcasm>,g if any_point_you_wish();
I've heard solid arguments in both directions as to whether internal corporate use counts as distribution,
By whom? The only time I've ever heard anyone suggest that internal corporate use counts as distribution was by the MySQL morons as an attempt to scare up business. The FSF even came out against them saying they were wrong and their arguments were damaging to the community.
How we know is more important than what we know.
Is it possible to do two distinct forks simultaneously, if you're the one doing the coding on both forks? Couldn't your employer argue that your contributions to the personal fork are inevitably derived from the code you wrote for their fork? And if you write your fork first, and then soon thereafter write the employer's fork, isn't the employer's fork inevitably derived from your personal fork, since you wrote both?
I think a single person simultaneously (or even with weeks) writing both forks is a bad idea, at least from a legal "who owns this code" standpoint.
I'd also like to note that I work for a large company that knowingly pays me to do exactly this all day. I write proprietary software using GPL libraries and such all day. We just don't distribute it.
That could come back to bite them quite badly. What if one department gets spun off as an independent business at some point in the future? Not solving this problem up front could create some hidden costs for your employer.
http://michaelsmith.id.au
Any work done before he worked for them is his copyright and he could release that but any work done after his hire is theirs and as long as they keep it in house, there is no violation.
This varies very much from country to country. In many European countries the work you do outside work is your own. In the US that should also be true, but your employer is allowed to create contracts which take away everything you should own. So, the summary doesn't give us enough information. You need to know a) where exactly this is happening b) what contracts were in place c) what exactly the guy did; what discussions he had and exactly what comments are in the code. Generally he shouldn't post that information since his posting would be discoverable in any lawsuit. He should discuss everything with his lawyer since, in civilised countries, that kind of discussion protects any speculative things he may say that might be harmful to him from being available to his opponents.
=~ s,(.*),<sarcasm>$1</sarcasm>,g if any_point_you_wish();
It is legislation, not case law. Section 35(6) of the Australian Copyright Act 1968: "Where a literary ... work ... is made by the author in pursuance of the terms of his or her employment by another person under a contract of service or apprenticeship, that other person is the owner of any copyright subsisting in the work ... ." Computer Software is a 'literary work' for the purposes of the act.
Note that it isn't all code written by an employee, just code written for your job.
IANAL, but you can look at the law yourself: http://www.austlii.edu.au/au/legis/cth/consol_act/ca1968133/s35.html
Contractors are not employees.
But the other point about this that is never mentioned is that contractors implicitly give licenses to whoever is paying them. Without a written contract that license is often interpreted VERY broadly.
How we know is more important than what we know.
This is a question that can only really be answered by a lawyer familiar with your circumstances and the laws in your jurisdiction. For example, by default, in Canada, if you're hired as a contractor to produce a work, you retain the copyright on that work (or so I was taught in my 100-level Business Law class). However, I don't believe this is true in the US. It's also not true in either country if you're hired as a salaried employee.
But really, plenty of other people will be offering legal advice, and the reality is that this matter won't go to court because it's not worth the time or money for you or the university. You can get a lawyer's opinion that you're in the clear to release your work, but even that's only so helpful to you -- if you threaten or bully your employer, that may just set them against you. (On the other hand, it may be just the thing! Maybe they need to see that you won't be pushed around. Different people respond to different tactics.)
The most elegant solution to your problem is politics. Convince your boss's boss and your boss's respected colleagues that your work would be better off shared -- people's opinions are ultimately derived from the opinions of the people they respect. You've made good use of an open-source base, right? Make sure they understand that there's value in tapping into that community. Allay their fears. Show them the positive side. Get people on your side.
If you can swing this right, it won't matter what the legalities are because the one of the university's officers will sign a waiver disclaiming interest in the code and you'll be in the clear for sure -- and your boss will be pleased at having done something good.
Sure, you should have got the signature before you started working; then you wouldn't have to spend cycles on this problem. Still, it may be fixable.
And if that doesn't work, just remember: the implementation is twice as good and ten times as quick to write when you've done it once before!
Just a guess, but I'd say their lawyers would nail said employee to the proverbial wall. Theft of trade secrets comes immediately to mind. Bear in mind that, as a company employee, the fact that he has a copy of the code/binary in his possession does not count as distribution. As I understand it, this is because he would be considered as part of the corporate "person" while under the employment of the said corporation. If he leaves the company with the code in his possession it would almost certainly be considered theft and not distribution. This would leave him with no rights to the code at all.
The contract didn't convey copyrights, therefore the copyrights are still his, NOT his employer.
Copyrights must be transferred by explicit contract. Not "oh, you paid me, so I guess your demand must be right".
Since the work contains GPL stuff, the university get a non-transferrable license to the combined work and a transferrable right to distribute/sell to others under the GPL.
Absent any contract specifying ownership transfers, it's still the author owns copyright.
NOTE: if the university don't abide by the GPL they are in license violation even if the contract DID convey copyrights unless they have the GPL part taken out.
This is no different tan any other copyright license.
An easier problem than they have with BSA. After all, the spun off company won't have the original license and that original license will have the parent company on it not the spin-off. Therefore they'll need a new license for all commercial software.
This is an additional cost for the company when spinning off a branch.
NOTE: the GPL is satisfied if BOTH the parent and the spin-off get GPL rights to the code. This doesn't cost anything.
This should answer your question: http://www.gnu.org/licenses/gpl-faq.html#GPLRequireSourcePostedPublic
"The GPL does not require you to release your modified version, or any part of it. You are free to make modifications and use them privately, without ever releasing them. This applies to organizations (including companies), too; an organization can make a modified version and use it internally without ever releasing it outside the organization."
No, Alice owns nothing in your scenario, and has no standing to sue.
True, but the Alice/Bob/Claire situation doesn't match the summary:
"I am a recent graduate, and I've been working on my own on a project that uses GPL-licensed libraries. Later a university department hired me, (...)
Unless the hiring agreement contained an explicit copyright assignment, anything he contributed before he got hired will give him standing to sue if they violate the GPL.
Live today, because you never know what tomorrow brings
It's not a gray area as the GPL explicitly says that it does not cover use, only distribution.
How we know is more important than what we know.
Assuming the company owns the copyright to the modifications they made, no they wouldn't need to provide their modified source to their employees. One of them must have the source to have developed the modifications but there's no propagation in what you described. With the GPL, the copyright holder is the party of reference, not the coder, employee, PHB, or anyone else.
Even better answer: http://www.gnu.org/licenses/gpl-faq.html#InternalDistribution
No, in that case the organization is just making the copies for itself. As a consequence, a company or other organization can develop a modified version and install that version through its own facilities, without giving the staff permission to release that modified version to outsiders.
That could come back to bite them quite badly. What if one department gets spun off as an independent business at some point in the future? Not solving this problem up front could create some hidden costs for your employer.
One thing to remember if you don't worry about the source code itself, but about obligations that you might enter into by using GPL'd software: By distributing executable + source code _together_ you have done everything that the GPL demands from you. Nobody has any rights towards you at all. So if you spin off another company, give them the executable and the source code.
If you don't do it that way, then suddenly _anybody_ in the world has the right to request source code from you.
The FSF does not have standing to sue unless they own Alice's work that Bob is distributing. Alice would have to assign copyright of her code to the FSF for them to be able to do so.
Are you adequate?
consult a lawyer, but IMO the key thing you said is:
"I did start the project on my own. And, since no written or verbal agreement was ever made to transfer copyright over to my employer, I question whether they can claim that they now own the extended version of the project."
it was yours to start with. they paid you to do some extra work on it. there was no transfer of license.
they may "own" any of the work-for-hire stuff you did while employed by them (depends on the nature of the employment - usually, in simple terms, if you're a contractor, you own your work but if you're an employee, they do) BUT THEY DO NOT OWN THE COPYRIGHT, AND THEY DO NOT OWN YOUR PRIOR WORK.
BTW verbal agreements are worth the paper they're written on - doesn't matter what they claim you said, if they can't produce a signed transfer agreement, it means nothing. same as if an employer verbally agrees that you will get paid quadruple for working overtime, unless that's standard practice where you work it's unenforcable unless it's in writing. and same as if the salesman says you can opt out of the contract at any time for any reason without penalty - if it's not what the contract says, it means nothing.
never trust a verbal agreement. they're worthless. this is true anywhere, not just in employment.
BTW, crap like this is why i *NEVER* sign an employment agreement without carefully looking at the clauses to do with ownership of work. if it says anything other than "what i do during work time on work equipment is yours, what i do on my time on my own equipment is mine" i send it back for another edit. i've had one or two bosses quibble about that until I ask them if they want to start paying me for 24 hours a day rather than 7.25.
(that question was always a good answer to the occasional managerial whinges about long hair and beard too)
What if the organization, eg CorpInc, took software released under the GPL and made modifications to it. Then they installed the modified versions to their own computers. The modified version is clearly under the GPL, because it is a derivative work. However is CorpInc required to give it's employees that use those computers the source to the modified version? If they are, then by the terms of the GPL the employees can give the source, and binaries, to others.
I don't believe so, since you have a company installing its own software on its own computers. That's not distribution/propagation/release/whatever.
Rampant carbon sequestration destroyed the Dinosaurs' tropical paradise. I'm here to help repair the damage.
Uhhh.. "it depends" is always the answer.. but in general work for hire is owned by the employer. And as for the first two situations you described, they're identical. Whether Alice is extending MySQL-commercial-license vs MySQL-GPL-license is irrelevant, Bob owns the work Alice does. I think you're as confused as the other people I've replied to, and I wish people on Slashdot would learn to read the entire thread before replying..... but I'll repeat. If I extend a GPL licensed work, I own my own work, it is not licensed under the GPL until I do so explicitly. It does not automatically become GPL licensed.
How we know is more important than what we know.
Actually the copyright on any code written "during work time" (or otherwise understood to be part of a job, be careful with that), is not the coder's to licence as he pleases, so it does not even matter what is in the employment contract. The code will be considered a "work for hire" (google that exact term for more information : it is the term used in copyright law, and is legal jargon)
His employer owns all rights to the code, except for 2 things :
1) the employer cannot deny the coder actually wrote that code (up-front attribution is not required, on-demand confirmation is required, e.g. "I want to hire person X, did he actually do the work in his CV on project Y ?" must be answered truthfully)
2) the coder gets to show, demonstrate, explain the functionality of the code to anyone he pleases*, **
(and -but be more careful- the coder is free to distribute extracts out of these materials for educational purposes)
* which can include limited distribution, e.g. in a job interview conducted over mail, however it must be clearly understood to not be used for anything other than portfolio work
** this explain bit can be used to get the code into the GPL program legally. The essential point is that the coder gets the work in, with his only involvement being explaining what it does to someone else, WITHOUT exchanging any of the protected work. In response to specific questions you can then (afterwards) use things like pseudocode. The coder cannot legally do this himself, but there's no law against him guiding -no matter how closely- another to do it. Given legal precedent, it would be very wise not to touch the computer of the guy doing the commit for any reason. If possible, document the exchanges made (do them over email ?, note down somewhere (in your gmail box for example) that you talked over the phone and what you talked about, or provide small "meeting reports", again mailed to yourself, that'd be a great help to any lawyer if it ever becomes a legal case)
Distribution, creation of derivative works (a second implementation of it by the same coder of the same thing would most likely be considered a derivative work, especially if parts of the code would turn out to match perfectly), and/or use in any manner other than described above is a violation of copyright law (and most likely also a serious violation of your employment contract)
And, frankly, don't tell your boss you're doing this. There's no legal necessity here, just common sense. Oh nothing in this post is legal advice for any case at all, it is merely a small summary of part of copyright law for informational purposes. It might be wrong, not applicable in your state, ... so use at your own risk. Contact a lawyer for legal advice.
You might be able to claim that your implicit permission was based on the equally implicit assumption that the rest of the code would become part of the same (open source?) code base.
Oooh, that could be a sweet end-run.
This work is licensed under a Creative Commons Attribution 3.0 Unported License.
Personally I think he'd be going at this from the human angle.
It's a university?
The careers of Academics are generally heavily based on publishing the work they've done with their names attached.
For coders it's less explicit but having a large body of published work can also be important and academics generally get the idea of open source.
Talk to some senior academics you get on well with.
Talk about it the same way as you would if the university were not allowing you to publish research done on uni time.
They may not like the idea and weigh in on your side which would be a big help.
Worst case you don't really get anywhere.
Best case some bullish professor will arrange things so your work gets published.
You may end up with some academics name on the code along with yours.
Storming about and arguing about who owns the code is very unlikely to do any good since you probably don't and the GPL doesn't help you on that score.
Allies in the right place are worth a thousand lawyers.
Also doesn't every recipient of the binary+source get permission to redistribute that?
Yes, they retain that right. The main point he was making is that you are only required to make the source code available to someone you gave the binaries to, not the general public. That is one point of the GPL that often gets misunderstood, you do not have to give your GPL code to the public per se, only to those who you selected to have the binaries. If they further distribute the binaries, you are not responsible to provide the source code to those 3rd parties. This means you can sell GPL binaries, and only provide direct copies of the source to those customers, and never the "public". This is a feature of the GPL, not a bug.
Tequila: It's not just for breakfast anymore!
So, as I understand it, there are 3 pieces of software here. First are the GPL libraries; let's call them 'A'. Then, you have the software you did as a hobbyist, let's call that 'B'. Finally, you have the work for hire, called 'C'. C depends on B, and B depends on A.
It's clear that they own C, and there's nothing you can do about that. On the other hand, you own B. If you publicly distributed B under the GPL, you are probably screwed here. In that case, there's nothing to distinguish B from A, and your only recourse might be some technicality in the GPL. For example, if you used the GPL v3, you may be able to use the stuff about software patents to prevent your university from using it.
However, if by releasing B under the GPL you mean you just used GPL software and considered it free, you may be able to turn around and teach them a lesson here: assert ownership over B, and demand that they produce written proof otherwise. You could demand that C be open-sourced in return for being allowed to use B.
That being said, though, you were stupid to do closed-source work on your own open-source project. Not only will you have to fight for access to your own work, your knowledge of the closed-source work will probably 'taint' any contributions to the open-source one to such a degree that they could probably claim work you do on it, even if it's off their payroll.
In the future, don't be so trusting of your employer. When I do open-source work for hire, I create a private github account and make the repo publicly available and GPL-licensed from day one. All of my work on the clock is then contributing to an externally owned and operated repo.
Oh, and I get the corporate overlord's approval of open-sourcing the thing in writing.
Someone else answered it in a long fashion, but to put it short: You only have to provide the source code to those entities you provided the binaries to, NOT the general public. Otherwise would create an undue burden on the original programmers.
If you make Program A, give me a copy with source, and I sell the binaries for $10 each (or just hand them a disk free), you are NOT responsible for providing the source code to those customers, *I* am, and you would have the legal right to force me to give them the source code since *I* distributed the binaries. I don't have to provide a copy of the source to anyone else, only those I gave/sold the original binaries to.
Tequila: It's not just for breakfast anymore!
The blunt truth is that he made two stupid mistakes.
1) He didn't discuss the university's position on this and get it made clear in the contract in the first place, and
2) He came to Slashdot for legal advice.
It's been shown countless times that Slashdotters in general *do not understand how law works*. They assume that one can deduce how the law works logically, and that's how it is.
Well, it's not. The only way to know about how the law works is to learn how it works. It's not always logical, it's not always the way it *should* be (in a reasonable *or* in a logical world). I've actually been criticised for pointing out the latter, as if pointing out that the law doesn't work in that idealised way meant I endorsed its flaws (which is another stupid thing to do, but Slashdotters aren't always the detached paragons of common-sense that some would like to see themselves as).
Even if they understand the GPL in isolation, this case requires one to know how this relates to employment laws, jurisdictions, "works for hire", blah blah...
Bottom line- being an expert in IT and related fields does not qualify you to answer legal questions. IANAL, and neither are the vast majority of those contributing to this thread. And the problem is sorting out those who really *do* know what they're talking about from those who simply think they do.
"Slashdot - News and Chat Sites Deviant". (Click "homepage" link above for details).
You can try, then when you go to court, the judge will smack you in the face for trying to sneak around your legal obligations.
When you write something on your own with clear knowledge of the requirement for your employment, using knowledge you gained FROM your employment, you have a really HARD time trying to convince the court that it really was 'your' work.
The government and courts have been dealing with people far sneakier than you for several thousand years.
Persistent Volume manager for Kubernetes - https://github.com/dwimsey/openshift-pvmanager
I agree with #1, and sort of don't also. The university should have taken a look at the license on his software before committing time and resources to improving it. If it was GPL'd before employment(and had copyright notices intact), the Uni can't distribute derivatives without also licensing them under the GPL.
I don't think there is a judge alive who would honor any submarine copyright-transfer terms of an employment contract, so unless he transferred them to the University with an intent to do so, he still owns the original works up to that first day of employment. The university cannot simply usurp his copyrights on the original works by employing him.
Your rant is apt for a lot of cases, but this particular issue is something a lot of /.'ers really understand. Most lawyers, if you ask them about GPL and copyrights, their eyes will glaze over. This guy really needs to decide how important this is to his job.
If push comes to shove, his job will be over but he can prevent the school from distributing his derivative works under other-than-GPL terms.
You can't legislate goodness. Let each to his own destiny, by will of his freely made choices.
I am not a bookmark manager, but what the hell. Those folks actually spent a bit of time thinking about this shit, you know. If you're still confused after reading the FAQ, direct your question to GNU or FSF, not bloody slashdot.
May we live long and die out
That's not correct. Unless you did the work as a university employee, or someone compensated by the university for doing the work, there is no transfer of copyright or assignment of any rights, just because you were a student at the time.
Now if you have been granted a scholarship, assistanceship, or employment with the UNI. There may be some term of the contract that assigns ownership to the university.
There may also be some matters that have special terms -- for example, students conducting a masters or P.h.D. thesis, may be required to assign or sign certain rights to the school, over their final submission (such as the right to publish), before it can be accepted.
But that is an exception to the rule.
While you have a point, and professors are more likely to be receptive to this kind of thing, publishing research is really the wrong metaphor here. It's more like a professor with a patentable invention - and these days, the patent almost always goes to the university automatically.
Warning: Apple/Nintendo fangirl. Likes her electronics cute & cuddly. May be rabid.
Level 1) If I read the summary correctly, you wrote some code before you came to your employer. If you GPLed that code, then the code written prior to your employ is yours to do with as you want. Unless you somehow signed something to give rights over to your employer.
Level 2) Any changes you created to the project while under the employ of your employer. These belong to him/her/it. You cannot distribute them without permission. If your employer does distribute the code, because of the GPLed libraries and stuff, the employer must provide source code. But if your employer does not distribute the code, then he/she/it is free to keep it a secret and not release it. These are the rights under the GPL, it mostly protects the rights of an entity that the software is distributed to. But without distribution it doesn't apply.
I'm definitely not a lawyer. But it seems to me your best options are the following:
1) negotiate to buy a license to the software. If you get your employee to distribute it to you somehow, then you can demand the source and you are free to do what you want with it (via the terms of the GPL the employer cannot revoke your right to modify the code if you have the program distributed to you).
2) if your employer ever creates a commercial product from your code, buy it and then demand the source code and you are free to do what you want. If your employer ever makes a commercial product cheaply, buy a copy and then demand the source code, under the terms of the GPL
This is a very good point. Make the right arguments about academic freedom with regards to your code. So long as the code is not an implementation of business logic, a university will be hard pressed to win an argument over your academic freedom to publish, particularly if you intend to publish in a manner which could bring more accolades to your university.
This sort of question is exactly what the Software Freedom Law Center is for.
Just keep swimming.
No. You read GPL 2 2(b) incorrectly.
If you provide binaries and source, then you are correct.
But, if you provide binaries and an offer of source that offer is transferable. Then, anyone who gets binaries from anyone else can demand source from you.
In Liberty, Rene
BTW, you don't need a written employment contract to require that everything you do as an employee belongs to the company you work for either. Same for students - your enrollment is sufficient to say that you agree with the policy, and therefore give up your rights. Don't like it - enroll elsewhere.
It's not the same. By law, when you do work for another company who commissions and pays for the work, if there is not a contract, then 'work for hire' is assumed. The company who paid for and commissioned the work receives the copyright.
If you are a student, then you are not paid for any work. There is no automatic transfer of IP, regardless of someone else's "policy". By law a transfer of copyright can only be made with a signed agreement. There is no such thing as implicit transfer of ownership of copyright exclusive rights, there must be a signed contract.