Re: GNU license files rules replacement guidelines with BSD one
http://www.openbsd.org/policy.html Scroll down to the section 'Permissions - the flip side' and consider the consequences of the statements in paragraph 4. This section is probably the biggest one that supports my view that GPL cannot be recinded and after initiation and that all GPL code should be carefully considered with regard to future use in GPL environments even by the original author. I am open to having that view changed if you have a more definitive source of reference, however, it may well be the case that some of the flexibility that may be present in under one regional boundary isn't present in another region. To this end many licenses state that the licensing terms are in accordance with 'California state law..' or whatever, by accepting the terms you are therefore reducing ambiguity on the use of the license. -Andy -Original Message- From: Adam [mailto:[EMAIL PROTECTED] Sent: 05 April 2006 01:14 To: Andrew Smith Cc: misc@openbsd.org Subject: Re: GNU license files rules replacement guidelines with BSD one On Wed, 5 Apr 2006 00:15:02 +0100 Andrew Smith [EMAIL PROTECTED] wrote: GPL cannot be revoked by the author and, what is more, a new version being classed as a 'derived work' would still under the terms of GPL be classed as GPL and the original author couldn't do anything about it. Revoking is not involved here. The copyright holder can do whatever he or she wants with their code. If I made something GPL, I can turn around and make it BSD licensed, or close the source and not license it at all, its up to me. If you can still get your hands on the code from when it was licensed under the GPL, then your copy is still under the GPL, and you can do whatever the GPL allows. But it has no impact at all on future versions and how I choose to license them. - Linus faces this issue with future versions of Linux, he doesn't like GPL 3 and won't accept it but he can't take GPL 2 off Linux kernel since it is an evolving project and is derived from previous versions. No, he can't take the GPL 2 off because hundreds of different people own the copyright to GPL code in the kernel. All of them would need to agree to re-license it. Adam
Re: GNU license files rules replacement guidelines with BSD one
On Wed, 5 Apr 2006 11:01:22 +0100 Andrew Smith [EMAIL PROTECTED] wrote: http://www.openbsd.org/policy.html Scroll down to the section 'Permissions - the flip side' and consider the consequences of the statements in paragraph 4. This section is probably the biggest one that supports my view that GPL cannot be recinded and after initiation and that all GPL code should be carefully considered with regard to future use in GPL environments even by the original author. You simply aren't listening. Nobody is talking about recinding anything. This is very simple, and if you do not understand, then go ask a lawyer. The copyright owner can license their work under whatever terms they choose. Period. End of story. I can make up a different stupid license to release my code under every day for a year, and none of the previous license terms have any effect on me, or how I license it in the future. It only has an impact on the people licensing that code from me. Licenses allow other people to do things, the copyright holder can always do whatever they want, they don't have to agree to the terms of their own license. Adam
Re: GNU license files rules replacement guidelines with BSD one
Andrew Smith wrote: http://www.openbsd.org/policy.html Scroll down to the section 'Permissions - the flip side' and consider the consequences of the statements in paragraph 4. This section is probably the biggest one that supports my view that GPL cannot be recinded and after initiation and that all GPL code should be carefully considered with regard to future use in GPL environments even by the original author. I am open to having that view changed if you have a more definitive source of reference, however, it may well be the case that some of the flexibility that may be present in under one regional boundary isn't present in another region. To this end many licenses state that the licensing terms are in accordance with 'California state law..' or whatever, by accepting the terms you are therefore reducing ambiguity on the use of the license. Rescind and revoke are not the issue here. These are straw men. The original author(s) can *also* offer their works under *other* licenses in *addition*. There's a long history of copyrighted work licensed under multiple, concurrent, non-exclusive licenses. That's easiest if it's always been done that way for a given work, or if there's a single author to make the decision without consulting anyone else. This isn't practical (or even possible) for projects with hundreds or thousands of contributors, but it's very possible for projects with a small number of contributors. Asking won't hurt. Some will be adamant about being GPL only. Others really won't mind offering it under a BSD license as well. -- Darrin Chandler| Phoenix BSD Users Group [EMAIL PROTECTED] | http://bsd.phoenix.az.us/ http://www.stilyagin.com/ |
Re: GNU license files rules replacement guidelines with BSD one
On 4/5/06, Andrew Smith [EMAIL PROTECTED] wrote: http://www.openbsd.org/policy.html Scroll down to the section 'Permissions - the flip side' and consider the consequences of the statements in paragraph 4. This section is probably the biggest one that supports my view that GPL cannot be recinded and after initiation and that all GPL code should be carefully considered with regard to future use in GPL environments even by the original author. This section specifies that someone elsemay alter the copyright notices on files but that won't change who owns the copyright. It is the same with the license, someone else may change the written licensing terms but the original license still applies. However according to international copyright law, the author (or more specifically the copyright holder) of any work may change the distribution terms at his whim. In the case of the GPL, this means the author of GPL program X may decide to remove the source from the internet and sell it binary-only for 5K$. The only thing the GPL will do in this case is that people who obtained the source before it was pulled can continue to use and distribute it under the GPL as the author cannot revoke this license from them. No license can restrict the freedom of the copyright holder to do as he please with his work. However, with most GNU/GPL projects, there are hundreds or thousands of contributors and each one of them would need to agree to a license change to change the license of the whole project. That is why most big projects can't change their liccense. Back to the original topic, If the project you are talking about is yours (meaning you wrote it), ga ahead, change the license, you can. If not, you must ask each person who has the copyright to a part of the project if they agree to change the license. If what you are talking about is rather if you can replace some GPL file by an equivalent one but BSD licensed file, the answer is yes (as long as you don't copy-paste). The only caveat is that as long as there is even ONE GPL file in the project, the project has to be redistributed under the GPL as a whole. As for your second question, a file that is comprised of only an '#include shit.h' satement should be easy enough to replace (see Ted's suggestion) and you don't have to change the name of the file (at least with the GPL). I am open to having that view changed if you have a more definitive source of reference, however, it may well be the case that some of the flexibility that may be present in under one regional boundary isn't present in another region. To this end many licenses state that the licensing terms are in accordance with 'California state law..' or whatever, by accepting the terms you are therefore reducing ambiguity on the use of the license. -Andy [snip] Arnaud -- i think we should rewrite the kernel in java since it has good support for threads. - Ted Unangst
Re: GNU license files rules replacement guidelines with BSD one
Please guys, like I put in my original questions. Quote I don't want this to turn into a flame war however. If that's where it might be going, don't answer. Quote / Lets stick to the essence of the question. So far I got one good answer from Ted. Not sure yet that I fully understand it, or the process of it, but I am not interested at changing licenses from the author, etc. Bottom line is this! If I see a GNU software that I like and the structure of it makes sense, or I think it makes sense, but I don't want to correct the bugs in it because it will stay under GNU. At what point, or how can it be replace by a BSD one where it's need at the same time to be fully compatible with the GNU one, meaning the internal structure and the interface to the world of it needs to stay the exactly the same. How can some draw the line between be able to write your own BSD version using the same internal structures and in many cases the same function calls needed internally with the same in/out interface to the world and be able to have it under BSD instead of GNU? Does someone needs to have module in between their own applications to the outside world that may be going away in a few years to kill the GNU link between the internal structures, etc. Obviously this add overhead that makes it not so efficients and prone to bug as well. That's the essence of the question. I really don't care about the author right to change the licenses, if he didn't already, he/she never will do it. But the software itself might be still worth to be BSD. That's where I want to get the answer and the knowhow if that's even possible. How someone can and needs to respect the license and will of the original author, but use the idea and standard use in it to make a BSD version? How? For anything else place just drop it. That have been beat up to death so many times, lets not make it onces more please! That's not why I asked the question and it is sure not what I need to know either. Many thanks for your inside on the subject if any! Regards, Daniel
Re: GNU license files rules replacement guidelines with BSD one
On Apr 5, 2006, at 12:11 PM, Daniel Ouellet wrote: If I see a GNU software that I like and the structure of it makes sense, or I think it makes sense, but I don't want to correct the bugs in it because it will stay under GNU. At what point, or how can it be replace by a BSD one where it's need at the same time to be fully compatible with the GNU one, meaning the internal structure and the interface to the world of it needs to stay the exactly the same. How can some draw the line between be able to write your own BSD version using the same internal structures and in many cases the same function calls needed internally with the same in/out interface to the world and be able to have it under BSD instead of GNU? The code you write is owned by you. You are free to license it however you see fit; you can release your code as BSD-licensed patches to the original code, but you cannot alter the license on other people's code.
Re: GNU license files rules replacement guidelines with BSD one
On 4/5/06, Daniel Ouellet [EMAIL PROTECTED] wrote: Back to the original topic, If what you are talking about is rather if you can replace some GPL file by an equivalent one but BSD licensed file, the answer is yes (as long as you don't copy-paste). But what does that really mean. It sure is NOT that I can sit there and retype a printed copy of the software and then release it BSD for sure! That is copy-paste for practical purposes. That's really the part I am having problem with. I am not a layers, I don't want layers discussions, etc. In practical term, how can this be done and what's the line here that makes it either BSD or GNU for stuff you write that are inspired may be from GNU? Is code, meaning moving of data, processing of data is it, but that you can still use the same data structure because it make sense and reeds to be compatible? I don't know and I am trying to find out. If you retype the same structure does it then make it GNU? The idea is to see what it does and then do the same with your own ideas. For example, if you have a function that takes a string argument and reverse the characters in it under GPL. You take what it does (reverse character in a string) and re-implement it with your own code. You can keep the same interface to the function (meaning name and parameters) as long as you impelment the functionality yourself. As for data structures, I am not certain but I tend to agree with Ted meaning they are not copyrightable and you can copy them. (I know I did with some) I don't know, what's the rules, how can it be done if even possible. Like many times we see people say inspired from GNU code, but it's BSD code. What's the inspired is define at. How far does it goes? Inspired means you see a good idea and you do the same general idea without using the exact same lines of code. That's my question. The only caveat is that as long as there is even ONE GPL file in the project, the project has to be redistributed under the GPL as a whole. That I understand very well. But as stated below As for your second question, a file that is comprised of only an '#include shit.h' satement should be easy enough to replace (see Ted's suggestion) and you don't have to change the name of the file (at least with the GPL). So what this really mean? It means that a file with only #include statements is hardly copyrightable and can be copied at will. Also file names are not copyrightable and you are not requiered to use new names. The copyright (and consequently the license) applies to the code and only the code. Sorry guys, I also have some difficulty at time to understand the nuance of the language, so I may look think at times, not my fault. I try however. I need to understand this if only for myself, but I guess it may be useful for someone else as well. Thanks and I am very sorry for the subject, I know this is a very sensitive subject but I really don't want this to be a battle of merit on the licenses, etc. Don't worry this topic has not even been approched yet, and I intend to keep it that way. I am only interested on how a GNU project can become a BSD project and the process and step in getting there, if that's even possible. In your case it is not really changing a GNU project to a BSD one but rather rewriting a GNU one under a BSD license. Correct me if i'm wrong. Thanks Daniel Arnaud -- i think we should rewrite the kernel in java since it has good support for threads. - Ted Unangst
Re: GNU license files rules replacement guidelines with BSD one
** Reply to message from Daniel Ouellet [EMAIL PROTECTED] on Wed, 05 Apr 2006 15:25:52 -0400 Back to the original topic, If what you are talking about is rather if you can replace some GPL file by an equivalent one but BSD licensed file, the answer is yes (as long as you don't copy-paste). But what does that really mean. It sure is NOT that I can sit there and retype a printed copy of the software and then release it BSD for sure! That's really the part I am having problem with. I am not a layers, I don't want layers discussions, etc. In practical term, how can this be done and what's the line here that makes it either BSD or GNU for stuff you write that are inspired may be from GNU? Is code, meaning moving of data, processing of data is it, but that you can still use the same data structure because it make sense and reeds to be compatible? I don't know and I am trying to find out. If you retype the same structure does it then make it GNU? I don't know, what's the rules, how can it be done if even possible. You may need a so-called clean room reimplementation -- where one team of people analyzes a piece of code and writes documentation for it and a separate team uses that documentation to write an equivalent piece of software (and is very careful to never look at the original code). AFAIK if this is done properly the new code is free of the old copyright, but I am definitely not an expert on the subject. Dave -- Dave Anderson [EMAIL PROTECTED]
Re: GNU license files rules replacement guidelines with BSD one
Arnaud Bergeron wrote: For example, if you have a function that takes a string argument and reverse the characters in it under GPL. You take what it does (reverse character in a string) and re-implement it with your own code. You can keep the same interface to the function (meaning name and parameters) as long as you impelment the functionality yourself. That's good to know. Exact same functions name and parameters can stay as is as long as content is different. So, that's one thing clear now. As for data structures, I am not certain but I tend to agree with Ted meaning they are not copyrightable and you can copy them. (I know I did with some) But can it really? Someone could argue that the structure is part of the intellectual property of that design and as such is under GNU. Doesn't mean two different users in two part of the world can't come up with the exact same structure because it make sense, but again, is it proper to do so? Can it really be that the exact same structure use keep the same name, variable types, order, etc. And then use by different function or implementations and then be OK to use and NOT step over the right of the original author(s) then by doing so? Inspired means you see a good idea and you do the same general idea without using the exact same lines of code. Thanks, that's two clear answer now. It means that a file with only #include statements is hardly copyrightable and can be copied at will. Can it really? I guess if in the end you make it KNF compliant and the order of the various includes are changed, but are the exact same name, including names form the original project, it's OK? If so, that would be the third rules then. Also file names are not copyrightable and you are not requiered to use new names. The copyright (and consequently the license) applies to the code and only the code. That would be the forth one at this time. Don't worry this topic has not even been approched yet, and I intend to keep it that way. Thank you!!! In your case it is not really changing a GNU project to a BSD one but rather rewriting a GNU one under a BSD license. Correct me if i'm wrong. Yes and making it a drop replacement as it is process along the way, AND keep fully compatibility with third party modules, so meaning obviously it can't be fully BSD until the last files is replace, but part of it are replace by BSD files and code as it is progressing however. But keeping the line between the right of the authors and the replacement BSD version. That's what I am struggling with. Obviously if no one would care about licenses, it wouldn't be a question, but that's wrong. How to proceed to the end goal and respecting the original Author wishes and license of choice AND make the transition to a BSD final version. Thanks.
Re: GNU license files rules replacement guidelines with BSD one
On 05/04/06, Adam [EMAIL PROTECTED] wrote: On Wed, 5 Apr 2006 00:15:02 +0100 Andrew Smith [EMAIL PROTECTED] wrote: - Linus faces this issue with future versions of Linux, he doesn't like GPL 3 and won't accept it but he can't take GPL 2 off Linux kernel since it is an evolving project and is derived from previous versions. No, he can't take the GPL 2 off because hundreds of different people own the copyright to GPL code in the kernel. All of them would need to agree to re-license it. Relicensing, as people have mentioned, is rather difficult with big projects that have many contributors. But for the sake of the argument, it must be added that it's not something that cannot be done entirely. Mozilla.org, for instance, recently have completed the relicensing process such that now most or all mozilla.org code is now available under your choice of three licences. However, it must be added that it took mozilla a very, very long time to do this process with one very dedicated volunteer, gerv. (The process was stuck several times because it was not possible to locate some contributors etc.) http://weblogs.mozillazine.org/gerv/archives/2006/03/relicensing_complete.html
Re: GNU license files rules replacement guidelines with BSD one
On 05/04/06, Daniel Ouellet [EMAIL PROTECTED] wrote: It means that a file with only #include statements is hardly copyrightable and can be copied at will. Can it really? I guess if in the end you make it KNF compliant and the order of the various includes are changed, but are the exact same name, including names form the original project, it's OK? Why do you need to change the order of #include's? This is plain boring, only an idiot would waste someone's time arguing that the '#include' statements from their work are stolen. :) And at the end of the day, it's not a bad idea to order includes in the abc order, and changing the order just to change it is not something that one should do...
Re: GNU license files rules replacement guidelines with BSD one
If you want a good insight on the issue of legal implications of creating derivative/non-derivative works with functionality that is present in existing implementations, I suggest that you follow the SCO vs. Linux lawsuit, the arguments around the issue are very relevant to your question. For what it's worth, you could even try to revamp the old ATT claim against BSD. Here is where you might want to start: http://en.wikipedia.org/wiki/USL_v._BSDi http://en.wikipedia.org/wiki/SCO_v._IBM_Linux_lawsuit P.S. If you don't know already: SCO is the company that now has more lawyers than it has hackers.
GNU license files rules replacement guidelines with BSD one
I am not sure that this is a simple question, but what's the rules if any, or guide line someone can go under to replace files and code with BSD type in a project for example. I need some help understanding what's right and what's wrong and where the line is if any and what's proper and what's not. Let say that you have a GNU project and that you need to keep full compatibility with the system calls, in/out, same function names and in some cases structure, but the way the process is done is different. At what point is it correct and possible to ripe a GNU file and replace it with a BSD file if possible. Can that be done? What about if a file only have include files left in it, but is still under a GNU license. I guess it can't be replace right? Example would: /* * license text * bla bla bla * */ #include shit.h and shit.h is a file from that project but the content of shit.h have changed or will changed. Is that burn in for ever in it's life and the only way to do this would be to have a new file called newshit.h and then call it from ever everywhere shit.h was called from. I hope my question make sense, I am trying to understand that process if that's even possible to understand it somewhat. This is very confusing to me. Reading on the subject doesn't provide clear guideline someone could go by if any. I don't want this to turn into a flame war however. If that's where it might be going, don't answer. I am just trying to understand the process and how it's getting done properly. I see on Google that some project were GNU and then got switch to BSD after some part that were include in the original project were replace by other BSD version. So, no more GNU was there, so it didn't apply anymore. Google give me huge results on the subject, but so far, nothing clean that I can understand properly. SO, I guess it's not an easy question. I hope I am not offending anyone asking that question! Thanks Daniel
Re: GNU license files rules replacement guidelines with BSD one
On 4/4/06, Daniel Ouellet [EMAIL PROTECTED] wrote: I am not sure that this is a simple question, but what's the rules if any, or guide line someone can go under to replace files and code with BSD type in a project for example. I need some help understanding what's right and what's wrong and where the line is if any and what's proper and what's not. Let say that you have a GNU project and that you need to keep full compatibility with the system calls, in/out, same function names and in some cases structure, but the way the process is done is different. At what point is it correct and possible to ripe a GNU file and replace it with a BSD file if possible. Can that be done? What about if a file only have include files left in it, but is still under a GNU license. I guess it can't be replace right? Example would: /* * license text * bla bla bla * */ #include shit.h and shit.h is a file from that project but the content of shit.h have changed or will changed. Is that burn in for ever in it's life and the only way to do this would be to have a new file called newshit.h and then call it from ever everywhere shit.h was called from. I hope my question make sense, I am trying to understand that process if that's even possible to understand it somewhat. I am just trying to understand the process and how it's getting done properly. I see on Google that some project were GNU and then got switch to BSD after some part that were include in the original project were replace by other BSD version. So, no more GNU was there, so it didn't apply anymore. Google give me huge results on the subject, but so far, nothing clean that I can understand properly. SO, I guess it's not an easy question. I hope I am not offending anyone asking that question! My understanding is that the owner of the copyright can change the license at any time, but that that change only applies to new versions. So: if you are forking someone else's GNU code then you can't arbitrarily make it BSD (because of the restrictions in the GPL). I think, though, that it doesn't work the other way; the very open BSD license allows for someone to take BSD code, make a change (or none?) and relabel it all GPL. if you are the original author of the code (and you haven't given the rights away) then you can change the license at any time, but that change only applies to new versions. You can take down old versions but it's still perfectly legal for anyone with a copy of it to post it and continue to work on it under the old license. Correct me if I'm wrong! -Nick
Re: GNU license files rules replacement guidelines with BSD one
Nick Guenther wrote: My understanding is that the owner of the copyright can change the license at any time, but that that change only applies to new versions. So: if you are forking someone else's GNU code then you can't arbitrarily make it BSD (because of the restrictions in the GPL). I think, though, that it doesn't work the other way; the very open BSD license allows for someone to take BSD code, make a change (or none?) and relabel it all GPL. if you are the original author of the code (and you haven't given the rights away) then you can change the license at any time, but that change only applies to new versions. You can take down old versions but it's still perfectly legal for anyone with a copy of it to post it and continue to work on it under the old license. Correct me if I'm wrong! -Nick IANAL, but I believe the copyright holder can offer the work under any license they wish, even without making a new version, as long as the licenses are non-exclusive (i.e., if I've licensed my work to you exclusively, then I can NOT also license it under GPL or BSD.) There are examples out there of multiple simultaneous licenses. So, the trick here might be to ask the author(s) if they'd be willing to put it out under BSD as well as GPL. Many open source people use GPL by default and are not fanatics about it either way. Worth an email... -- Darrin Chandler| Phoenix BSD Users Group [EMAIL PROTECTED] | http://bsd.phoenix.az.us/ http://www.stilyagin.com/ |
Re: GNU license files rules replacement guidelines with BSD one
No, I don't think this is quite correct. GPL cannot be revoked by the author and, what is more, a new version being classed as a 'derived work' would still under the terms of GPL be classed as GPL and the original author couldn't do anything about it. - Linus faces this issue with future versions of Linux, he doesn't like GPL 3 and won't accept it but he can't take GPL 2 off Linux kernel since it is an evolving project and is derived from previous versions. If the author, however, stated that the code could be used within GPL projects with a primary license being an alternative to GPL and that the use of the software within GPL projects was under the proviso that the rights of the author and the original license weren't broken then GPL couldn't be enforced... strictly speaking this may mean that you wouldn't be strictly legitimate in using the software in many GPL license scenarios since the licensing terms conflict, however, some 'open source' communities don't seem to care about that as much as we do. -Andy -Original Message- From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED] On Behalf Of Nick Guenther Sent: 04 April 2006 23:49 To: OpenBSD-Misc Subject: Re: GNU license files rules replacement guidelines with BSD one On 4/4/06, Daniel Ouellet [EMAIL PROTECTED] wrote: I am not sure that this is a simple question, but what's the rules if any, or guide line someone can go under to replace files and code with BSD type in a project for example. I need some help understanding what's right and what's wrong and where the line is if any and what's proper and what's not. Let say that you have a GNU project and that you need to keep full compatibility with the system calls, in/out, same function names and in some cases structure, but the way the process is done is different. At what point is it correct and possible to ripe a GNU file and replace it with a BSD file if possible. Can that be done? What about if a file only have include files left in it, but is still under a GNU license. I guess it can't be replace right? Example would: /* * license text * bla bla bla * */ #include shit.h and shit.h is a file from that project but the content of shit.h have changed or will changed. Is that burn in for ever in it's life and the only way to do this would be to have a new file called newshit.h and then call it from ever everywhere shit.h was called from. I hope my question make sense, I am trying to understand that process if that's even possible to understand it somewhat. I am just trying to understand the process and how it's getting done properly. I see on Google that some project were GNU and then got switch to BSD after some part that were include in the original project were replace by other BSD version. So, no more GNU was there, so it didn't apply anymore. Google give me huge results on the subject, but so far, nothing clean that I can understand properly. SO, I guess it's not an easy question. I hope I am not offending anyone asking that question! My understanding is that the owner of the copyright can change the license at any time, but that that change only applies to new versions. So: if you are forking someone else's GNU code then you can't arbitrarily make it BSD (because of the restrictions in the GPL). I think, though, that it doesn't work the other way; the very open BSD license allows for someone to take BSD code, make a change (or none?) and relabel it all GPL. if you are the original author of the code (and you haven't given the rights away) then you can change the license at any time, but that change only applies to new versions. You can take down old versions but it's still perfectly legal for anyone with a copy of it to post it and continue to work on it under the old license. Correct me if I'm wrong! -Nick
Re: GNU license files rules replacement guidelines with BSD one
On Wed, 5 Apr 2006 00:15:02 +0100 Andrew Smith [EMAIL PROTECTED] wrote: GPL cannot be revoked by the author and, what is more, a new version being classed as a 'derived work' would still under the terms of GPL be classed as GPL and the original author couldn't do anything about it. Revoking is not involved here. The copyright holder can do whatever he or she wants with their code. If I made something GPL, I can turn around and make it BSD licensed, or close the source and not license it at all, its up to me. If you can still get your hands on the code from when it was licensed under the GPL, then your copy is still under the GPL, and you can do whatever the GPL allows. But it has no impact at all on future versions and how I choose to license them. - Linus faces this issue with future versions of Linux, he doesn't like GPL 3 and won't accept it but he can't take GPL 2 off Linux kernel since it is an evolving project and is derived from previous versions. No, he can't take the GPL 2 off because hundreds of different people own the copyright to GPL code in the kernel. All of them would need to agree to re-license it. Adam
Re: GNU license files rules replacement guidelines with BSD one
On 2006/04/05 00:15, Andrew Smith wrote: GPL cannot be revoked by the author Cannot be revoked but can be re-licenced by the author under another license. Where there's more than one author, all must agree to the change. This leads to dual-licensed code having things like http://www.digium.com/disclaimer.txt for submitters. Yeuch.
Re: GNU license files rules replacement guidelines with BSD one
On 4/4/06, Daniel Ouellet [EMAIL PROTECTED] wrote: Let say that you have a GNU project and that you need to keep full compatibility with the system calls, in/out, same function names and in some cases structure, but the way the process is done is different. At what point is it correct and possible to ripe a GNU file and replace it with a BSD file if possible. Can that be done? What about if a file only have include files left in it, but is still under a GNU license. I guess it can't be replace right? if there is code in the header file, it can be copyrighted. however, i don't believe interfaces for the most part can be. if you want to play it safe: find a partner. write down there is a function called foo taking 2 int arguments. there is a struct called bar with fields a, b and c. slide paper across desk to partner; tell him to start typing.
