Slashdot Mirror
On the Ethics of a Code Split?
McWizard asks: "We've recently had a code split at a project I'm leading. (No name given, as this is a question, not an advertisement campaign). While both projects have done some major design decisions in opposing directions, we've been keeping a close eye on the changelog of the spinoff for small changes that could be used. So, whenever we've found an interesting piece of code (mostly GUI stuff, nothing longer than 20 lines of code), we transferred it to our project and gave credit to the spinoff team in the changelog.
What does Slashdot say on that matter? Is this unethical or are such things fair game?"
"Yesterday, I was contacted by the leader of the spinoff project who told me that he's quiet angry at us for doing that and that it's considered unethical and rude to copy code from the spinoff.
As both projects are under the GPL, we have an opposing opinion on that matter and we've more than once invited him to copy code from our project. Nevertheless he's thinking about obfuscating his changelog and only open the source as packages when he's doing a release, which is, as he says, his right under the GPL."
Legally, there's nothing wrong since both projects are GPL'ed (I presume).
Ethically, I don't see anything wrong with it. In the end, it's your design decisions that are going to make a difference, which is why the code split in the first place. In fact, there's no reason why both projects shouldn't take code from each other; if there are common areas where there's actually no disagreement, this will help to reduce duplication of effort.
Gan Family Homepage
Anyway... if he doesn't want people using his code under the license he chose, he shouldn't have licensed it that way. It's like people on the web that don't want you to link to them.
Given that their code is GPLed, you'd have to release your code for free.
are you losing sleep over the matter? if not. don't worry about it and get on with the better things in life. let the weenie at the other project be a weenie.
abcdefghijklmnopqrstuvwxyz
That is the spirit of the GPL! You are allowed to copy and use GPL code if your code is also GPL!
If this a GPL project then go ahead and live the GPL dream.
Weird.
The other developer obviously does not understand the GPL. Of course you can use the code, just as long as you preserved the copyright notice.
Use & share the code - thats the whole point of the GPL anyway.
My pics.
If the idiot who forked from you really wants to go closed source with it, he's going to have to change the license, and I bet most of that code was written by people on your side of the camp. I wish him lots of luck getting them to agree to license it to him under closed terms. If he just wants to close the CVS repository, or obscure the changelog, that's up to him, and the GPL permits this, but that would seriously hurt his fork, as people would be far less willing to get involved with it.
So in short, it's not at all unethical. But is it rude?
Again, I'm going to say no. It is, after all, a GPL project. You have to expect your code is going to wind up reused in other GPL projects sooner or later. That's a sign that you're writing good code. He should be flattered, not offended.
In the long term, the politics are likely going to wind up killing one or both projects, so I'd suggest you try to keep the moral high ground, as it were, and let this guy run his fork into the ground. It sounds like he's well on his way there already.
How am I supposed to fit a pithy, relevant quote into 120 characters?
The GPL says it all basically. If they wish to add a restriction or attempt to persuade anyone that it's unethical or rude to do things, then they're not abiding by the GPL.
Therefore they cannot continue distributing the code they did not themselves write.
Yes? Then I fail to see how this is an ethical question at all. If they didn't want others using it, they wouldn't have made it available for others to use.
Never let your ego stand in the way of improving the software.
If it's a change that you want to see in your own code base, and you're allowed to use it, then go ahead! Could you imagine what crap you might be forced to use if you had to do everything differently from now on?
Disgruntled XFree86 developer, are we?
Real programmers can write assembly code in any language. -- Larry Wall
... die by the GPL.
You're fine. If they didnt want to share, they shouldn't have stayed with the GPL.
At least you're giving credit, which is a pile more then most bother to do.
- Adam L. Beberg - The Cosm Project - http://www.mithral.com/
Isn't the whole point of Open Source to share ideas and improve everybody's work?
As long as you give credit and don't try to pass it off as your own, I don't see the problem... unless you are selling this product, in which case it's a tricky situation. Maybe take the idea and give credit but rewrite the code your own way?
If you shared code originally, what's wrong with sharing it now?
illegal? no unethical? well if he's asking you to not do it I would say so.
Why do free software if you can't use anybody else's code? Isn't that what the whole point of open source is supposed to be?
The (X)Emacs split only helps the VIle!
Kiss. Make up. In KISS makeup. Emacs akbar!
No, you must have everyone and everything which does not act/think/behave exactly as you.
Have a nice day.
If it is under the GPL and you are giving proper credit, I don't see the problem. I see this kind of sharing as part of the entire point of putting one's work under the GPL.
There must be some bad blood for him to say something is under the GPL, except for you.
Viv
Gmail invites for ip
He's a twit. How did he get his code base in the first place? By copying it, under GPL, from a community of people who wrote it and released it.
They didn't have veto power over others using their code and neither does he.
It's open-source. If he doesn't want certain people re-using the code, well, then he shouldn't release his code under the GPL. Trying to restrict use of open-source code because he has a personal grudge with a project he split off of is the real unethical behavior.
If he wants to do this and not share with everyone, he needs to start over with his own commercial implementation from scratch. Until he does, just tell him to suck down a nice big mug of STFU.
If it's unethical to legally bring in code from the spinoff project with full credit given and the license terms followed, then how could it have been ethical for them to legally take your code base and spin it off within the terms of the license?
I see both as being perfectly fine, but if they're going to get angry about it, that's just hypocracy on their part. (At least that's what it looks like without reading their side of the story.)
If it's an open source project their improvements are fair game, and it's in the best interests of both branches to share and use each others improvements on the common core parts of the software.
The difference between Canada and the USA is that in Canada healthcare is a right and gun ownership is a privilege.
Of course, much depends upon the licenses, but pretty much all of the open source and free software licenses are based on lofty principles of the sharing of information and code.
If you believe that the spinoff developers really adher to the principles embodied in their license, not only is it okay to borrow, they should encourage it.
It's as simple as that.
Gentle Reader,
If he doesn't want you to use his code, he shouldn't license his additions under the GPL, whereupon you can sue him into the ground.
Since he is licensing it under the GPL (as he must, since the original codebase is GPL), you should gently remind him of that fact.
this guy needs to grow up. (Mods: I'm not trolling here). This is the worst thing about working in software: some developer's baby-like attitude about the code they write. Every fucking place I've worked has always had some guy who's pathological about his code. (for the peanut gallery: no, it's not me).
What is it about coding that draws these types? Was it being beaten up in school, and now they're nuts about the one thing they're good at?
Your hybrid is not saving the environment. Its purpose is to make you feel good about buying something.
As far as design direction goes, you guys -- the project leads -- should just agree to disagree. That doesn't mean you need to hate each other.
GPL-wise, there's nothing wrong or unethical about what you're doing. Respect-wise... just talk with each other. I'm sure those guys would appreciate borrowing bits of your code here and there as well.
I worked on a commercial game at a company where we had another team working in parallel with us on a second game. Although we were using the same 3D engine, the games were fairly different from each other. We frequently merged code changes that we found useful and they did the same. I think it resulted in better products for both of us.
Can you imagine human history without being able to use other people's good ideas? I mean even if it's not derived? "I'm sorry, you can't have that steam train - I represent the estate of the ancient greeks, and we have a patent on the steam engine."
Having said all that, accreditation is nice - aknowledge the work that people have done, it's cool that you are doing this. This is what polite people in academia do - just recognise the derivation of the idea, then use it with what you're doing.
T
The license says you can, and more than that it is completely within the spirit of the GPL. I'd go as far as saying its one of the cases that motivates people to use the GPL over other licenses (always being able to merge changes from other public forks and branches).
Oh, that already happened.
If you have a good reason, just split the code - emacs survived it, XFree86 survived it.
Actually under the GPL, the other guy doesn't have to make his changes available if he never plans to distribute the new project in any way.
Arguably, it might have been more polically aware to ask permission before using the code, but I'd say the more serious problem is that the leader of the spinoff doesn't appear to fully understand the concept of the GPL. Anybody can take a project and expand on it. That code can, in turn, be added to any other project. It's all about sharing and showing your stuff, so someone using your code should be taken as a compliment, not theft.
Maybe you could try and talk to him and ask why this is a problem; perhaps it's a matter that can be settled. In any case I wouldn't borrow any more of their code until the matter is cleared up since that would only escalate the feud.
===== Murphy's Law is recursive. =====
to have generated a story on /.
Of course you can take code from another project with a compatible lisence, and of course he can only release poorly documanted code with packaged binaries.
Take a step back, and stop treating your hobby and it's related community's politics as if it's a life or death international incident. And of course, the same advice applies to the guy who wants to intentionally mess up his documentation to make code sharing inconvenient.
Honestly, I think the vast majority of the world's open source nerds could use an ego deflation.
I rememeber when me and my other personalities were doing a program for class, and due to internal politics, the code got forked. well long story short, I turned in thier code, and they got mad, and I was like "whatever, whatever I do what I want"
But seriously, code forks, and splits are tricky things. especailly if its not an amicable one. In this situation, even though it is allowed by the Liscense, maybe the best course of actions is to abide by the wishes of the other party. I doubt that this is the first time, that this has happened in open source, and will not be the last. When you have a lot of talented people working on identical projects, in competition, with open doors to whats under the hood, people will look.
thusly it is probably in the best interest of both projects to keep out of each other's kitchens as it were. This provides both the incentive of boosted competition, and also the added benefit of better inovation. becasuse as long as you are copying, your code is not evolving.
If the other little dweeb released his code under the GPL too than I say suck it dry. Use all the work without a second thought.
Of course if you guys share so much code why not just make a 3rd library of the shared code and be done with? E.g. take the intersection of your projects and make that a new library. That way you can focus on your particular tweaks and still be happy.
Of course I can come up with these cool ideas because I'm a forking genious.
Tom
Someday, I'll have a real sig.
Obviously, there was a separation (a split). So while one spouse may think they can take stuff out of the other spouse's fridge, that spouse may have been saving that piece of pie for dessert. However, if it was a separation and not a divorce, they're still married and if one spouse won the lottery, in most states it would be split 50-50.
Possible things that could happen: the offended fork might put a poison pill in with its code; the fork that's taking ignores any protests until the projects are completed; the offended fork closes off any acces to the code; or the forks agree to spoonfeed each other.
My inclination is that both forks should share -- and if there's animosity, the problem runs deeper than just a fork in the code.
--
jon
Is it ethical? Hell, yes! The whole idea of Open Source is to produce the best damn code possible. If it weren't, there'd be no point. It'd just be an ego-trip and flag-waving exhibition. Sure, some projects are just that, and some developers are only concerned with themselves. Such projects and such people rarely last, either in open or closed-source environments. When all you can see is yourself, you're obstructing the view of any goal you might want to reach.
You cut bits out & give them credit. They do the same with what you produce. In the end, the fork will either produce two completely different products that were initially entangled, or will re-merge when it's finally understood that the different people were viewing the same problem, only from different viewpoints and/or with a focus on some specific part of it.
For what it's worth, I say go for it. The other person has neither ethical nor legal ground to stand on, if it's GPL, LGPL or BSD.
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
If we are talking about the GPL, not only is it ethical, but it's expected and encouraged by the community at large!
Soccer Goal Plans
Some of the posts seem to imply that other leader of the other fork is somehow mad about the poster using code from the other fork. Has this person whined about it, or are we just assuming this?
My other computer is a Jacquard loom.
I've seen this happen in pretty important chunks of code - even gcc - which is pretty sad.
As a maintainer for a file system, I try to treat people as "customers". Sure, unless they're paying, they don't have any legal rights, but there is still some moral obligation to serve. I try to add the features that people want without breaking the design goals etc. I'm sure this is easier with a file system which is very deeply buried than with a userpsace program where everybody has a beef about itty-bitty features.
Engineering is the art of compromise.
If both projects are under the GPL, there's no reason you shouldn't take his code and use it in your own. He has to realize that both projects are based on the same code and are aiming to do close to the same thing ... and also that he forked the code and is releasing it under the GPL himself (under the rules of the GPL). If he doesn't want you taking his GPL code when he took yours, then he's just being unreasonable and should rewrite everything and keep it closed. Additionally, aren't you guys supposed to be on the same side? Why would he want to hinder your progress on the way to completing a project?
In short, you're on the same side and are making two GPL programs based on the same source. You are free to use his code and he's free to use yours. If anything, it's good.
Lack of eloquence does not denote lack of intelligence, though they often coincide.
Well, since the original story submitter didn't want to tell me who he was, I figured I'd dig.
His email address was listed as mcwizard@gmx.de.
A Google of that turned up a forum containing a post with both his email address and his name: Helge Richter
Google again for Helge Richter, and we get a Sourceforge profile listing three project affiliations:
MegaMekNet
MegaMek
and
Provoke
Scary world we live in, isn't it?
First off, I'd have a look at their code and see if they'd taken anything from me...
If anyone is being unethical it is the other party for trying to browbeat into place additional restrictions on top of the GPL
Open Source and Free Software work so well because no matter what differing motivations and desires different people have we all can all come together with a given licence as a basis for a sort of social contract.
If a party is trying to restrict what the licence in question normally allows then it is they that is being unethical.
Boffoonery - downloadable Comedy Benefit for Bletchley Park
For the curious, Google turns up that mcwizard is on the MegaMekNet and MegaMek projects. Both are games: Java clones of BattleTech.
...well, at least we finally know why Longhorn was delayed.
You are an idiot.
How, exactly, is it unethical to take small snippets of code from a fork? Remember, to start the fork the spin-off team took the original project's entire codebase. All of it. You are not in the wrong here. The fork has to maintain the GPL license (or completely rewrite all the pre-existing code). Given that the GPL made it ok for them to take your project's codebase and start a fork, they can not claim foul when you do the same thing to them.
This is all about someone's ego. Squash it or not as you see fit.
In other words, do *you* care what they think of your use of their code. In this situation, that is about all that really matters.
The guy obviously is distributing; he's running a public CVS server and making public releases every so often. Each of those is distribution under the GPL. But your point deserves to be modded up; people sometimes forget that you don't have to distribute at all.
How am I supposed to fit a pithy, relevant quote into 120 characters?
If it's a spinoff, then his code base is a derivative of another work. Coupled with the GPL, there is nothing 'unethical' or 'rude' about taking code from this fork. If anything, it's unethical for this moron to prevent such use. I suggest you discuss his behaviour with other project members. Both projects will be better off without him.
I completely agree with this. One could also, easily, make the argument that he took your code when he forked the project. I'd even be willing to wager that he's taken a lot more of yours than you've taken of his. Maybe pointing this out might help put out some flames (probably not).
Jeremy Logan's Website.
This seems like a lot of hand-wringing over something not worth the time.
...
Why not say (friendly, or cordial, or casual, or merely polite, however the split you describe has left things) "Hey, we're looking through your code to see if anything applies to our half of the great divide. Is that OK with you?"
If the source is freely open, why is it a question? If you don't find it "ethical," why would someone else's opinion matter to you? If you *do* find it ethical, even more so
timothy
jrnl: http://tinyurl.com/c2l8yr / foes: http://tinyurl.com/ckjno5
There is a difference of opinion. In both patches and directions. The trick here is to be the best person possible in these situations.
a) Post minor bug fixes between code to their bug notification system. Prove that you have good faith and are not sabotaging their ability to compete, you have a difference in opinion about methods but you are working on the same goal.
b) Post a request for developers to cross post any bug fixes into your system to the list. Request that the project sponsor post this on their page. (Sounds like they will decline but you should be polite and officially ask).
There is no real ethical debate here. The reason for the fork is apparent and ANY code changes that makes the project a better one is for the common good. Is is anoying when the competition "stands upon the shoulder of giants", hell yes.
Ego and programming do not mix and is the biggest problem with most developers.
You meant the spirit of GNU. The GPL just tries to force you to abide by the spirit of the GNU project.
Anyway, even if the other developer has to big an ego, it's always a good idea to make him calm down with soothing words. After all, everything he wants is probably a little bit of recognition. The need for recognition is what drives Open Source, not the need for good software, right?
Isn't that the whole point of Free Software?
Free Manning, jail Obama.
It's *OURS*, not mine.
That's the whole idea.
Also, copying bits from one GPL program to another GPL program is not out of the ordinary. This is a constant in open source software.
To minimize confusion, every developer should probably read (and understand) the GPL.
http://www.gnu.org/copyleft/gpl.html
"You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty;"
-Joe
If you were both working on two commercial projects for a company (with a reasonable management)... he probably wouldn't be working there anymore. That's assuming that a fork over differences in design decisions would be allowed in the first place.
The point of GPL is sharing. The other team leader is an egotistical idiot. Take what you want. If he were anything but an idiot, he would be flattered, and he would take anything from yours that came in handy. But he's one of those arrogant fools who thinks that everything he does is better than everyone else. His opinion is not worthy of consideration. So don't consider it.
Dont let this bother you. If the moron wants to hide his code then he should try and go closed source. Then hopefully be sued into freedom (from his house, car, life).
This sounds like a case of phpnuke.
http://www.megamek.net/
mcwizard@gmx.de = submitter email
google search
First result! You WILL have publicity, darn it!
I wonder if this might be the project: http://sourceforge.net/projects/megameknet/
Don't think that a small group of dedicated individuals can't change the world. It's the only thing that ever has.
If he's threatening to obfuscate his changelog...keep his changes you want rolled into a single patchfile, and apply the patch with the next major release. Credit the changes, surely, but don't make them whenever you see them. Do it all at once, or as a .1 release to the program.
Nothing unethical about it at all. The entire fork is based on code that you helped write in the first place!!!
I say the other guy needs to wash the sand out of his vananay and move on.
Your Karma is undamaged.
That other guy clearly doesn't understand what the GPL is all about. It sounds like he is more interested in owning the project than he is in writing code.
if two groups of coders parted ways but are still being paid by the same company, you put yer f***ing egos on the coatrack when you come to work and anything that anybody thinks up that makes any product better should be available to all within the company. "credit" is just for performance reviews. Attribution may be either useful or detrimental for code reviews, depending strongly on the culture of development in the company.
SLASHDOT: news for people who can't concentrate on work or have no life at all and got tired of yelling back at the TV.
To get angry at somebody is a deficiency of cracs?
Oh, you mean 'hypocrisy'. Yeah, sorry about that, I thought you knew how to spell...
A few years back, I had a project amicably fork from mine. Their project went in a considerably different direction, before swerving back more into a similar direction as my own codebase.
As time went on, both groups would cheerfully swipe code, bugfixes and ideas from each other, with thanks and credits in the checkin notes and changelogs. It was all friendly and in the open, so nobody minded.
Obviously, I see no ethical problem with this.
I remember reading about, I believe, an emulator that was released into the public domain. Afterwards, some people who liked the emulator found out another project was using code from the emulator without crediting it. They got very angry, until the creator of the emulator came out and said that's the reason he released it into the public domain in the first place. It's public code, he *wants* people to use his code.
Same thing with the GPL, I believe.
Wheel in the sky keeps on turnin'.
There is nothing wrong with what you're doing. That is exactly how the GPL was intended things to work. After all, he's using your code too!
McWizard in the red corner with Megameknet/Megamek:
http://sourceforge.net/projects/megameknet/
and in the blue corner urgru with mekwars:
http://sourceforge.net/projects/mekwars/
Is this what its all about?
Sounds like the "leader" of the spin off group is bitter about something (maybe it's why he spun off the code to begin with?) and is just being an ass. Maybe you should point out that he and his spin off project wouldn't even EXIST if it weren't for your project that they spun off from.
Of course, he can certainly obfuscate his code and changelog all he wants. Nothing legally wrong with that. He only has to release his changes when he releases his product in some manner as well. But if he does that, he probably won't be getting much community help. That's one of the great things about open source. If people want to use or contribute to one codebase because of political/legal/moral/ethical reasons whether real or perceived, then that's their right. If someone wants to look purely for the best technical implementation or the one with the 'nicest' community of developers that they can fit into well, etc, then more power to them.
At any rate, you are neither doing anything legally wrong nor ethically wrong. Not even ethically questionable imho. This is how the GPL works. If the other guy doesn't like it, he can just not release his changes under the- oh wait, he used your codebase to begin with. Welp, looks like if he has that much of a problem with it, he can go write his own from scratch and use whatever license he wants.
This is laid out in the open source definition, of which the GPL fits, which explicitly forbids obfuscated source.
Whether and how this applies to changelogs is another matter, since those could be interpreted as not being part of the source.
However, if the changelog is important for understanding the source, then I would interpret the GPL as regarding the changelog as part of the source code for the project, and therefore subject to the redistribution clause of the GPL.
Just don't do anything you wouldn't want them to do. Legally you're already fine, but thats the best moral test.
Pain lasts, kid. Its how you know you're alive. Sometimes I think this growing up thing is just pain management-TheMaxx
The GPL was not created with the intent of "getting shit done". The purpose of the GPL is to create a community where people contribute and share for the greater good of the community.
It's not about producing the best code possible or having access to free stuff or beating Microsoft. You're confusing Open Source with GNU.
Slightly off-topic, perhaps, but it's always worth reminding people that the FSF and GNU have an agenda, and that is to play nicely with one another. Everything else is secondary.
For this particular case, yes, it's entirely appropriate to use code from the other project. That is precisely the intent of the GPL - to make sure that people cannot hoard the work of others.
"We've recently had a code split at a project I'm leading."
So you WERE leading the whole project, now you're leading ONE of the forks? That's how I understand it.
TFQ is unclear on this, so I'm trusting the other posters who say that both forks are GPL. In this case it's technically fine to use the code while giving full credit, but from the tone of "is this ethically okay?" it seems the problem is more political than ethical. So...
Why not offer up any of the changes in YOUR fork in echange (even though they are technically available anyway through the GPL)? Are these not wanted? Why or why not?
What else is going on in this situation that you didn't tell us?
Tag lost or not installed.
He's being an obnoxious prat. A two year old who cannot share. He shold remember that all great things are built by climbing on the sholders of others. ( c.f. Newton, & Torvalds )
Was it unethical for him to take your program and make a spin off using all your core code? Seriously I would think it would be kinda unethical to prevent your pearnt program from takeing the modifications you made to their origonal code.. its the least you could do for them makeing all the core code in the first place. more over hes a twit. HONESTLY id be happy just that you credited me. If I had a dollar that somebody took my code from one project or another I would be a rich rich man. but its no skin off my nose.. Like most people im just flattered that some one liked what I wrote and bothered to steal it.
Is that you?
This distinction is exactly what makes the GPL so powerful, and IMHO why Linux won over the BSDs. If RedHat could keep "their linux" proprietary, there's no way IBM would support them in the manner they do today.
Not only is it NOT unethical, it's precisely what you SHOULD be doing. Anyone who thinks this is unethical completely misses the point behind the free software movement. Quite frankly, I wouldn't trust anyone who takes that kind of position either.
Sigs are awesome huh?
Say to him "No, rude would be if I told you to go get stuffed, like I'm about to do." You are using the code in a manner that isn't just permmited by the license, it's intended by the license.
I'm sick and tired of these fairweather open source developers. They're all for it when it means they can get a jumpstart on their project using freely available code and not have to ask permission. They're all for it when it means they look at what others have done for inspiration. They're all for it when it means they can attract more developers with the promise that their code won't be locked away to wither and rot so long as someone, anyone is interested in it. But once someone starts using it in a manner they don't approve of, they're up in arms.
Hey, that's the GPL. If it's all his code, he can stop releasing it under the GPL and use a more restrictive license. Otherwise, tell that arrogant bastard he needs to look down on all the GPL shoulders he's standing on and rethink his position.
I would say what you did is correct and how he is reacting isn't within the spirit of the GPL. Also how did he find that you are using his code unless he was viewing your code? He must have been browsing your code looking for improvements... It is all fair game with the GPL as it should be. I would say let him get mad and continue using his code as the GPL permits it.
Someone wrote better quality code and because it's GPL'ed, your code becomes higher quality without having to re-invent or re-write that bit yourself. Organisations like Microsoft can't do that easily, not without acquiring or licencing individual cases.
The flipside of this re-use is that if too much of new project code is from the other fork, people are going to consider the fork even more seriously than before.
Rather like Luke trying to kill Darth Vader.
"Everything is adjustable, provided you have the right tools"
I thought this was part of the point of open source software. I assume by the fact that they're giving credit that they're taking actual code, not just feature ideas. The great thing about this is that you can fork without completely splitting your development resources down the middle. The giving of credit is very important though, beyond the legal requirements in the source code attribution. You should credit them as loudly as possible, to avoid political problems, as the other project is a potentially very important resource.
WARNING: there is a trojan on your
Honestly, this sounds like a political problem, not a coding or ethical problem. Going by the description here (and I'm only a so-so programmer, and don't know the community in question, so I'm assuming the description here is accurate) someone didn't like the way things were run and the amount of emphasis on the features *he* wanted, and decided to fork the code. Even got enough people who agreed with him (or were malleable) to support his side of the project.
Good - evolution comes from competition, both sides of the fork are stronger thereby - it's one of the several reasons open source produces better code.
But he left the main fork because he didn't *like* the way they were running things, and then they have the sheer temerity to use *his* code. Them B@st@rds!
Which leaves you in the position of having to choose whether or not to ignore the spirit and letter of the GPL, leaving him his exclusive code, but preserve peace between the forks, or respectfully disagree, point out that he has the same option available to him, and use what you find useful, or even get nasty and tell him that he can keep his source secret, but needs to remove the GPL'd code from his project.
Those are the options I see for you. Unfortunately, which of those you pursue is a poltical decision you need to make, not an ethical or legal one, so you need to talk to your base, not slashdot.
That said - I would go to option two - respectfully disagree and exercise your rights, going to option three if he tries to make it difficult to do so, but I'm a very polite hardass when it comes to someone trying to infringe my rights. Your political situation may not have the stability to do so.
But it doesn't really sound like the open source community is ready to tale up arms on his behalf, so at least that part of your equation is answered -
An Invisible Entity of Vast Power whose existence must be taken on faith alone: Liberal Media
Theres open-source, which sometimes means you can only look at the code. Theres free software which sometimes means take the software, do whatever, but dont break it apart, take important pieces and use it to improve your own software.
But for GPL and BSD licenses, the authors really are offering their source code for 'whatever'. This includes taking pieces of their code, using in your software, and even not thanking or marking the original author of that piece of code. By releaseing software under GPL or BSD, youre really offering ALL that. If thats not OK with you, find another license.
Code's value can be measured in a few ways (1) money (2) recognition (3) effect on the market.
Most people code for money. If you take code from Windows and use it for your project, thats like taking cash. You'd have to pay cash to take that cash for proprietary companies.
Many people code for recognition. This is true for many smaller projects and a few big ones in the OSS arena. This is the major point of contention... they release the code under GPL or BSD but sometimes its not OK if someone 'steals' lines of code, and credit is not given where its due. These guys should find another license enforcing credits... or maybe just release binaries.
A few companies code for market effects. Examples are companies which invest in Linux or BSD's code to create a leverage against Microsoft, decreasing its power. One good example is Apple's OSX which creates the market for Apple hardware. They wouldnt sell the source code, nor would release an x86 version for recognition only. Another example is GPL, which in some ways forces software to be open, BSD doesnt.
Getting back to the topic... sure, if the license is GPL or BSD, take all you want. In case of GPL, make sure your license is compliant. In parts of the world, if someone offers you sweets, and you turn it down. Its offensive.
"Give orange me give eat orange me eat orange give me eat orange give me you." -Nim Chimpsky
A really interesting split to study is what happened to Wine a few years ago. In 2002, Wine was under the X11/BSD license. A lot of people wanted to move to LGPL and a pretty big debate occurred. In the end, a vote was taken and the decision to move to LGPL was made.
Obviously that's not a concern you had, but we'll assume you guys did do some kind of vote for forking the project and that it was a fairly civil process. If you didn't - well, that was the start of your problems and unfortunately it's not that easy to go back.
Now, if the fork you're talking about has multiple developers, what you should do is something similar to what Wine (actually Wine's X11 fork, ReWind) did - contact each developer individually and ask them for permission to use their patches. You seem to have one person who disagrees and it doesn't seem like you'll get their consent, but shouldn't you at least ask the other developers?
Then, make it easy for people to submit patches against your project as well as the one they regularly submit to.
So that's the nice thing to do. Keep in mind what you're probably doing is only a short-term solution. Eventually your codebases will diverge enough that it may not be worth trying to integrate patches. At that point, you're going to have to realize that two teams are duplicating each others work and figure out whether or not that's productive.
Try to keep in mind why you guys chose the GPL in the first place. If it's a license you truly believe in, then it's pretty hard to argue against people reusing bits of code.
----- obSig
Look, the whole POINT of the GPL is to take good stuff from other people's code, and (preferably) give them credit. Obfuscating GPLed code is like buying decaffeinated Jolt, or giving everyone on your Christmas list cash for Christmas: it's in direct opposition of the intentions and spirit of the thing. If he's at all tempted to do these things, he's in the wrong business.
If so, please post a reply under this article so people can find them.
Patrick Doyle
I mod down every jackass who puts his moderation policy in his sig. Oh, wait a sec....
Mostly GUI stuff. The only thing that would tweak me would be if my gewgaw was credited for, how to put this delicately... polishing a turd. In this case, a GUI is a sticky situation
Or, he could be a bit too territorial. It depends on what the gaol of the split is. Is it to co-evolve or evolve completely separately?
The whole point of the GPL is specifically to allow that sort of sharing and cross pollination. The inability to do that in proprietary code is why Free Software exists in the first place.
As long as you're giving due credit where credit is due (technically not required by the GPL, but I would consider it only honorable), then you're in the right. If the other guy doesn't like it, then his beef is with the way Free Software works in the fist place, not with you specifically.
--GrouchoMarx
Card-carrying member of the EFF, FSF, and ACLU. Are you?
All I can say is - forget licences and rudness. This is hypocrisy ! The pot calling the kettle black.
"I want alll of the code everyone else has written, but I don't wanna share any of my code with anyone else".
Will he honestly never take code from the original again.... Puhlllleeeeaaaassseeeee
Well - people like that tend to end up very lonely indeed.
lounge around on the blue couch
I understand and appreciate your side of the story, and based on what you have said I would agree with most posters here that you're well within your rights to do exactly what you're doing. In fact, it would seem that you're going out of your way to do the right thing in giving credit and even in questioning whether such actions are ethical or rude.
That said, I'd like to hear the other side of this story from the leader of the spinoff before passing final judgment. Of course it could be that the guy is just a jerk and/or doesn't understand the GPL, but let's assume for a moment that the guy is somewhat reasonable (since we may never get to hear his side). If that's the case, another possibility springs to mind: The guy is upset because he didn't want to fork the code in the first place but found the original team too stubborn/inflexible/closed-minded to work with. I could understand the guy being irritated if a group had refused to consider a design direction and then took code from his group's forked version, especially if that code somehow "symbolized" the changes that he wanted in the first place.
Anyway, is there any way you can convince the guy to submit his side? Either he'll prove that he's a jerk or we'll find out that there's more to this story than what we've heard so far.
sig != null
mshiltonj might not understand what you mean by "idiot" because he only knows one of the various synonyms for any term. So, for clarity, mshiltonj is an ass, blockhead, boob, booby, cretin, dimwit, donkey, dork, dumb ox, dumbbell, dunce, dunderhead, fool, halfwit, ignoramus, imbecile, jackass, jerk, kook, meathead, mental defective, moron, nincompoop, ninny, nitwit, pinhead, pointy head, simpleton, stupid, tomfool, twit, yo-yo.
Since this is an article about copying other people's stuff and giving them credit, that came from dictionary.com.
Fork me? No, fork you!
yeah, he has used reverse psychology on all of us to get us to go check out and play his mech board game now that we are all ready to get some practice in before the mech from alaska takes over.
What's "quiet angry"? Is that when he stares at you without saying something?
;)
My two step plan for dealing with the problem.
Step 1:
Politely and calmly explain it to him that as both code bases are GPL'd it's perfectly legal to do what you're doing. Also point out that he's benefitted from this arrangement by not having to recode everything to get the spin-off off the ground and doing what he's planning on doing will harm the spin-off.
Step 2:
If step 1 doesn't solve the problem then tell him to go fuck himself and use the code anyway.
Nerd: Derogatory term typically directed at anybody with a lower Slashdot ID than you.
What a dumbass thing to fight about. A code fork doesn't mean you ignore each other, ESPECIALLY with GPL code (which is SUPPOSED TO be shared and re-used.) You should be actively sharing code and ideas, not trying to keep things secret. Collaborating will make both branches better.
Building fiefdoms doesn't help anyone. Your goal should be the best finished software that your team is capable of. Squabbling won't get you good code and nobody has fun, either.
That is how a code split should be done! The idea is to have the most effective code (for both projects) while still moving in the direction that each project wants. If you don't borrow code, you are not being effective.
Take Wine and WineX for example. Eventually, the changes in WineX are put back into Wine (at least some, I'm not sure of the detail).
As a side note, the identity of a project is the components that make it up and the way they are put together (the overall architecture). Reusing components from another project doesn't turn your project into what the other project is. Even if all components are reused (none written from scratch), the value is in how they're put together.
I see no problem with your copying code from the forked project. As you have said, both projects are under the GPL, so there is no legal restriction on taking the code that I am aware of. Further you are crediting the forked project with the changes, so I'd say your ass is covered in an ethical sense too.
As for the other project leader's idea of "obfuscating his changelog and only open the source as packages when he's doing a release", he's certainly free to do that (as long as the source is available he's not violating the GPL), but it seems to me he'd be shooting himself in both feet just to spite your project.
Bottom line, just keep doing what you're doing and let the twit blow off his steam however he wants.
/~mikeg
Just because there's been a code split doesn't mean you don't agree on other fundamental design choices. As such, and considering that this is a GPL'd project, good pieces of code (and ideas embodied therein) should be shared.
At the same time, I'm not so hot on the fact that you took code fragments (or perhaps the ideas embodied therein), possibly expanded on them, and didn't give credit where credit was due.
Share the code... take the code... and notate where it came from in your source.
and now he's mad you're using HIS code?
Where does he think the base code came from?!?
I see no problem with it. If it's GPLed you have the freedom to do what you want with it, as long as you follow the GPL.
I can't believe how everyone here is getting this so wrong. Of course it is unethical. This guy wrote that code, and by golly, they have a right to it.
If everyone is free to go and look at their code, modifying it, or taking pieces and using them elsewhere, then who can ensure the integrity of their code base. How can we ever trust the project or the programs they are writing if just anyone can get to his source code.
For one thing if they do, it will be far less secure, because prying eyes can see into his code for bugs to exploit.
What do you think it is, Open Source or something?
Ok, let me see if I understand this correctly...
Some guy forks an *entire* codebase... presumably several KLOC. That's fine, it happens a lot and is to be expected. Nothing wrong with that at all.
Now, this guy gets all pissy because you integrate small sections of the new code into your *own* codebase? He has the audacity to bitch when you reuse small chunks after he's "liberated" an ENTIRE codebase? Hell, I'm *delighted* when someone reuses part of my code, and I've liberated code from other people on plenty of occasions as well. When someone else does something well, the best way I can say "thank you" and "wow that kicks ass" is to liberate it (with proper attribution of course) and propagate it in my own code.
(ok, maybe the BEST way is to FTP them a sixpack of beer but I'm still working on the matter transmission libraries so that's not an option atm).
Tell the guy to go piss up a rope. The thing that kills good Open Source projects the quickest is prima donna pain in the ass people with egos the size of montana who think the rules don't apply to them. Someone should lock him in a room with a copy of the GPL and not let him out until he fully groks it.
-- Gary F.
In every case I've ever heard of, the primary reason why a fork has happened is because the lead of the original project was percieved to be an obnoxious megalomaniac. From what I've read this was true of XFree86, and from what I've been reading if it happens to Gnome, it'll be true there as well. (And yes, I'm privately inclined to believe it was at least partially true in the case of the Emacs/XEmacs fork as well ;-))
It sounds like the leader of the project you were involved with is now attempting to verify this truism by preventing you from copying the parent project's code to your new tree. Tell him that unless he either a) is the original copyright holder, and b) therefore wishes to change the code's license, (in which case he fairly obviously never intended to abide by the GPL in the first place) that he can go and perform an anatomically impossible act with a shovel with your blessing, because as long as the GPL is binding on the project, he won't be able to do anything else.
To RMS' credit, while he might not have been happy about the XEmacs fork (and he wasn't...I've read the email archives on this) but other than claiming Richard Gabriel had shown a "bad spirit" he never explicitly tried to stop it from happening to my knowledge, precisely because he would have known that forking is one of the rights that the GPL specifically grants.
The right to fork is crucial, because it protects against that part of human frailty which causes the behaviour of some of us to degenerate into fascism. If the leader of a project that you've devoted considerable time and effort to for whatever reason suddenly decides to start being a control freak, the right to fork ensures that the effort you've already invested will not go to waste. You can simply copy the project and relocate said copy to your own site/machine, and then continue working on it.
I agree completely that credit should be given in the changelog/wherever else to whoever has worked on the parent code, but for the parent project's lead to try and prevent forking of it if it uses the GPL is completely wrong, IMHO. In the XEmacs situation RMS might have tried to dominate people in spirit, but in practice he was able I think to recognise the necessity of abiding by his own rules.
Sounds like he doesn't mind using the work of the others that contributed to the GPL, but doesn't want anyone to use his code.
Of course, we only get your side of the story, and while I can tell you've gone out of your way to be fair and present a balanced view, getting the other guy's take on the situation is just as important. Technically, under the GPL, you are allowed to use his code. Technically, under the GPL, he's free to incorrectly document the change log.
In real life, though, it sounds as if mistakes may have been made on both sides. It's hard to tell without more details.
Your options, in my view boil down to:
Deadend your fork.
continue on doing what you're doing.
stop coping his code.
Read the change log but do your own coding.
I'd add "talk it out and come to a solution you can both live with", but if you were able to do that, you wouldn't have forked.
Necessity is the plea for every infringement of human freedom. It is the argument of tyrants; it is the creed of slaves.
However, I do see a potential problem. It does sort of defeat the point of the split if both projects are virtually identical. Now if you were against the split from the start maybe you don't care and if these are minor changes it probably doesn't matter. But as a general principle, I think we are in many ways served by not having to rely on one developer (be it you or this other guy).
Mathematics is made of 50 percent formulas, 50 percent proofs, and 50 percent imagination.
Their code gives you a license to use the source as you see fit. If they don't like it, too bad for them.
The person who writes the patches/modifications retains its copyright (unless the project has everyone assign their copyrights to a single entity), and the GPL does require you to mention this. So long as you do that, you're in the clear.
If the other developer doesn't like this, there isn't a whole lot they can do about past instances, but there are things they can do to slow you down. One thing most people don't realize about the GPL is that:
The primary requirement is that the developer has to make the source to the program available upon request to anyone they have distributed the binaries to. Thus, if you want to make things inconvienent to others, you can restrict the binary distribution, and then require someone to make a request in writing for the source, which you can then send via regular postal mail on diskette, CD-ROM, or as an OCR-able print-out (as the GPL does stipulate "machine readable"), for a fee of $100.
You, as a "competing" project, would wind up forced to play catch-up, as there would be a delay between when the binaries were produced, and when you could gain acccess to the source code for it.
However -- and here is the important part -- doing this would completely stymie their project in the process, and will probably kill it off. If accessing the source code is difficult, the developer isn't going to be able to attract other developers, and won't be getting patches from users. Many potential users would probably be turned off by the added hassle of getting the source code. And besides which, any user or developer which does get the source code could turn around and start redistributing it for free using whatever mechanism they desired.
So there are things they can do to try to slow you down if they really wanted to, but the extra barriers are also going to be barriers to their users, and they'd have to trust each of them to not redistribute the sources (as they can't restrict them from doing so via a license agreement).
Ethically you haven't done anything wrong. Technically there are things the other developer could do to slow down the possibility of you getting any of their additions (only use developers they know and trust not to redistribute the source code, provide binaries only online to registered users, providing sources only upon request and then only via mail), but unless they have a big bank account with which to bankroll continued development, it would probably hurt them more than it would hurt you (as the added hassles would probably allow you to poach all of their part-time developers, and users who value easy and open source code access).
Yaz.
"Yesterday, I was contacted by the leader of the spinoff project who told me that he's quiet angry at us for doing that and that it's considered unethical and rude to copy code from the spinoff.
Just about any behavior you can think of is rude to someone on the Internet.
Don't get me wrong, I'm not one of the "Do whatever you like, and tell anyone who complains that they're an oppressive nazi" sort of people. I like it when people are civil, and have some manners.
But some people are overly anal in the other direction. I'd mention specifics, but that would just engender a pedantic flame-war over the items I've mentioned... so I'll just say that even staying within some pretty sensible, civil, friendly bounds you'll still run into people who believe that you have in some way offended or slighted them.
steve
Oh, you're not stuck, you're just unable to let go of the onion rings.
I see no ethical problems here. More, since both teams are willing to reuse, true meaning of "opposite direction" is only lack of perception of wholeness. Both projects will merge in the future, taking rich of features from both sides.
There you are, staring at me again.
then BSD is dying.
As copyright owner of this comment, I authorize everyone to defeat any technological measure which limits access to it.
Stop qaiting our time with stupid answers.
The GPL is all about ethics you pinhead.
He's not asking if it is legal.
of course everyone here thinks picking code out of the split is a good idea. but... let's consider the flip side for a moment:
why did the code base split in the first place? obviously, because a group of developers in the team felt they had a better vision or method or whatever than the team leads. a code split is only a last resort, so we can probably assume that the developers who went on to form the split put a lot of effort into trying to get their ideas into the original source tree and were unsuccessful.
so, now that the split team has got a project up and running and is writing new code that embodies their vision of the project, they find that the original team who probably rejected at least some of the split team's ideas before the split is now suitably impressed with the results to roll them into the original source tree.
the question the split team may be asking themselves right now is this: if our ideas and code are so hot, why didn't you pay attention to them originally? and, furthermore, if the original team is so impressed with the features of the split project, why don't they put their effort into working on the split instead of the first source tree?
not meant to be flamebait: just trying to consider the motivations and rationales of the split team since no member of that team was given the opportunity to present their opinions or views in the original post.
2 1337 4 u!
unethical but you should totally do it it's just one of those things
there is no leagle issue in doing it but, if i understand from your side of the story the guy asked/told you not to do it. if it was no other reson then he wants to controle his code he should not have gpl'd it. you said that it was just a few lines here and there. can you live with out it, probably? it may not be worht the aggravation if your concerd about it. 2ndly you nerver now if M$ would pay his out to challge the gpl in court. http://slashdot.org/article.pl?sid=04/11/15/181221 9&tid=109&tid=1
This post brought to you by: the marketing division of The Sirus Cybernetics Corporation
It's been said a few times over already but I just wanted to lend a voice in support. As long as you are giving proper credit (changelog and source), IMHO there is nothing wrong with you using code under the license in which it was released. It is entirely hypocritical that the leader of the spinoff project has a problem with this. Even if you were the spinoff project and copying code you would (again IMHO) still be ethically in the right. The fact that the spinoff leader has a problem with it, after copying so much code to do the fork in the first place, is absolutely shameful. You are on solid ethical ground. Perhaps ask them publicly why they feel it is a problem. I can see few arguments that could be presented by the spinoff leader that wouldn't be mocked widely.
On a personal and social footing, however, if you've got an angry 'contributor' then you've got a problem on your hands. If it gets to the point where he's obfuscating his change logs, it's going to hurt his project and the bad blood can't do you any good.
I'm guessing that he's upset about something else to do with the split (i.e. he may feel seriously unacknowledged for the work that he put into the project pre-split or dissed as a side-effect or something like that), and seeing 'his' code being 'lifted' into your fork is just re-opening old wounds for him.
I think you're gonna have to do something to diagnose and heal that old wound, or the whole thing's just gonna end up an infected stinky mess.
Free Software: Like love, it grows best when given away.
As long as you credit where it came from, and release the code as GPL, it is ENTIRELY ethical and a logical extension of the idea of OPEN source. It's OPEN so people can see it, understand it and reuse it, OPENLY; giving credit where it's due. That's part of the bloody point.
<flame>Sounds like this guy is being a prissy little punk.</flame>
Tell him to go check his premises. If he wants neat features closed source he should do it with a closed source project.
The next remark is false. The previous remark is true.
Now, would it have been a bad thing to let the other group/person know that you were doing this? Sure. But even if (s)he screams to high heaven about it, you are in the right and what you did is the very stuff that makes open source so strong.
--
If I actually could spell I'd have spelled it right in the first place.
Seems the consensus that has been modded up is that moving code from one GPL'd project to another is perfectly legit.
What if some one "borrows" code from one GPL project to an OpenSource-esque project that requires a license and some $$$s?
Root Question: Can some take the borrowed GPL code, and add to their project non-GPL'd project?
You shouldn't hide this problem from your userbase or the other contributing developers. It will be worse for you and your project in the end if you don't go public.
Just about any half-decent defensive driving course will tell you that being legally (and even morally) in the right won't do you a rat's tail worth of good if you end up getting run over by a truck.
Free Software: Like love, it grows best when given away.
I don't get it, what am I supposed to buy then?
... is the sincerest form of flattery.
"(No name given, as this is a question, not an advertisement campaign)" Someones worried about their bandwith costs......
That's what it appears to be, does anyone was the author the original developer, and and/or did he started the spinoff? There have been quite a few arguments about jumping on board the project and then spinning it off, etc..
I'd suggest replying to the guy with a limerick:
Do not look into laser with remaining eye.
"A language that doesn't affect the way you think about programming, is not worth knowing" - Alan Perlis
If he doesn't like people poaching "his code", he shouldn't use a free license.
If he starts to obfuscate everything, then he'll likely end up killing his fork anyway.
I see a lot of posts here that are assuming that the question came up because the person who forked the code is griping. Though the parent posting here doesn't explicitly say that, it is the first moderated-into-default-visibility where that possibility is implied. Hence I have chosen it for my reply.
The original posting doesn't claim that there ever was any gripe. It is phrased as a simple question, by someone who is just concerned, himself, about possible ethical issues.
Maybe it DID come up because there was a gripe. But let's assume not unless/until the the article author or someone else in the know says otherwise.
Having said that, I'll now chime in on the original question.
A number of other posters have already pointed out that due to the open license (clearly implied by the circumstances) it's squeaky-clean legal to backport any good pieces. And both because that's the intent of open licenses and because the fork essentially lifted the whole project, it's also fair. I concur with both points.
Additionally, from a practical standpoint, backporting the good stuff from the fork to the main reduces the divergence (and reduces the total effort). This is good for both prongs: It makes it easier for someone familiar with one to work with, or work on, the other. And it simplifies matters if the two forks are ever to be remerged into a single project. These two argue for merging, not just where improvements or bug fixes are major, but even if the improvement is minor, cosmetic, or even when it makes an arbitrary choice among several roughly equal alternatives.
So feel free to merge whenever it makes any sense at all for your branch of the tree.
Bantam Dominique roosters crow a four-note song. Once you've heard it as "Happy BIRTHday" you can't NOT hear it that way
Ok, I work in the industry in configuration management (pauses while developers gasp). Yes CM that poor mistreated child of the software development industry. My take is as simple as this.
Your branch (the other project) is fair game. You're all working together more or less and there is no hard rules between you as to who "owns" the code.
In my books citing the author is plenty and actually from a CM perspective you should always keep track of the original source of a block of code. I know they might think that they will spinoff and become something independant and standalone but if there was a need to split one day, there could be the need to integrate the next.
I think it serves the best interest of software to not have an ego about who wrote some lines of code. In the long run it pales to the accomplishments of a whole team or teams.
Oops, how did this get here?
09 F9 11 02 9D 74 E3 5B D8 41 56 C5 63 56 88 C0
This is not a question of ethics. If the developer responsible for the fork bothered to read the GPL then he would know that his claims are legally and ethically baseless. If the submitter bothered to read the GPL then he would know that he is wasting our time with stupid questions. The dev responsible for the fork already gave his agreement to have his code changes used by others when he chose to release code under the GPL. There is nothing left to discuss.
I've had one of the most popular Sourceforge projects for a number of years now (the popularity is waning now, for obvious reasons... but I was in the top 10 for awhile) - My project is ShowEQ. We had a code split with SINS, and SINS developed in conjunction with ShowEQ for a time.
We did incorporate a lot of SINS stuff back into ShowEQ, because I did believe some of the directions that SINS headed in were good, but the overall direction I did not believe was what was needed for the community. However, the code was not a drop in replacement into ShowEQ for current fuctions (or to add new functionality, etc...) so we used the SINS code as a starting point and wrote the SEQ code with SINS as a base idea.
Regardless, the point is that Open Source and GPL are meant to do exactly this. There is _NOTHING_ unethical/immoral about taking bits and pieces of code from other projects and using them in your own. That's exactly what SHOULD be happening. The maintainer of SINS contacted me about using some of the code/ideas from SINS and asked me to give him credit in ShowEQ, which I had neglected to do since we didn't take the code directly and drop it in to the SEQ codebase... but I agreed that giving SINS credit within SEQ was the right thing to do... so in your case, I would definitely attribute portions of the code to the other guys project, even thank him. But there is certainly nothing what so ever immoral about what you are doing with GPL code.
Whoever the guy is that said that is the immoral asshole for even suggesting that... especially if he is the one that forked the code base to begin with and is using other peoples code himself.
Urgru's webpage is absolutely hideous. Yuck! Looks like this is a merely an academic debate, from the lack of salesmanship coming out of that project.
We can neither love nor pity nor forgive. If you make a slip in handling us you die!
I always thought one of the benefits of the GPL was the fact that you (hopefully) wouldn't have to re-implement things fairly frequently. For example, someone could write a GPL'ed implementation of a GPS tracker. Other people producing GPS trackers could then use, and improve upon that original product, inheriting its strengths (and weaknesses, unfortunately) in the process. In the end, a solution for the problem would be found, the software created, and other projects could then base further code upon that refined work.
Is this the way it ever works in the real world?
Thats the way it works... If either party has issues, shouldnt have been open in the first place..
Its all fair... no 'ethical' issue exists to debate..
---- Booth was a patriot ----
So what, your GPL'd code is open source for only the people you like? That isn't the way it should work. If someone hates me, makes a fork of my program, and steals my code (I'm not saying this is the author, just a theoretical situation), I'd be HAPPY!
Don't you want people to use your code?
Isn't that what this is all about?
Leave your ego at the door, please.
...for people who don't bother to read it. Section 6, for example:
"You may not impose any further restrictions on the recipients' exercise of the rights granted herein."
This forker has no clue what he's talking about. It's a two-way street: the same rights that allowed him to fork from your code, allow you to take whatever you want from his code.
His accusation that this is "unethical" is just laughable. Sharing is the whole point of the GPL. He should read it sometime.
Does the other maintainer think it ethical to use the code base from the original project? Apparently so. In which case, in the gpl quid quo pro, his code is available to all (not just you) for use in *any* gpl'ed project.
Go for it!
J.
You're only jealous cos the little penguins are talking to me.
He thinks you're an idiot, so he forks the project. You then proceed to steal his code, proving that he did, in fact, have a better handle on what needed to be done. You then whine to Slashdot to make him look like an ass.
I feel bad for the other guy, but this is the price of freedom.
The concept of open source is that by opening the source, we can make better software. So I don't see why we cant copy from each other's code, as long as we give due credit in our release-notes, changelogs. I think the leader of the other project should consider working for Microsoft or Oracle if he has such a narrow view on open source.
Carpe Diem: Seize The Day!
In this case there is no question. The GPL is the license that people who want cooperation choose. If you choose the Modified Berkely Licenses or whatever, then incompatible forks are possible. The Mozilla Public License is specifically designed to allow incompatible forks.
The GPL is the license which says clearly and upfront:
Which is why forking is such a strong part of the Linux development model. And why you can feel that you gave fair warning. Everybody knows this; BSD people have moralised about this; Courts have made judgements about it; Microsoft has complained about it (they don't want to cooperate with anyone and have said so). The spin off doesn't have a leg to stand on.
Assuming that both projects are GPLed, I think being able to do this is one of the points of the GPL. Making an issue out of it is unethical in that case.
....the code forker has effectively became a code fucker...brilliant end to an eventful year! p.s. pardon me for posting a 2nd comment on this article.
Carpe Diem: Seize The Day!
Listen, Richard, I realise it's pretty hard holding all those LISP functions in your head, but do you really need to Ask Slashdot? Surely the Emacs community is able to help in matters of this kind! And don't be too hard on Jamie; he may be a bit crotchetty at times, but that night club of his is taking a lot of his energy at the moment, so he may seem a little less patient than usual. Give him time; once he sees the coffee-maker attachment you're putting into version 22, he'll probably want to un-fork just so he can use it. Don't lose hope!
I have discovered a truly remarkable
If both projects are GPLed, there absolutely nothing unethical about taking code from the other project (and vice versa)
I'd tell the guy "WTF" and point out that the code is GPLed and you can use as much of it as you want.
My email addy? should be easy enough.
If he takes code from others he should expect others to take code from him (if it's any good, that is).
HAND.
The only other thing you need to determine is what the other project is he is talking about. I could not find in in a 5 minute google.
Okay, I'm sure there are some egos involved, but really, 90% of the codebase is probably the same (if it's one of the projects I'm thinking of).
So what did the two teams gain by "forking"??? I'm betting not much more than some ego strokes. A couple of guys who "forked off" can say, "we know better than you" while odds are, that's exactly what the first team is thinking/saying.
It's a shame y'all can't get along.
Section 2a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.
Why it needs to be the file itself is obvious. Otherwise you could grab a source file, and no longer have the notice (quite common if you pick a small subsection of a large project, you don't want to sift through the other 99% of the changelog).
Now it might be very easy to be lazy with this (it is all GPL baby, and I don't care about my name being in the header for every little fix I make), and while it is all legally well as all the code is GPL, it is misrepresenting the modified code as the original. That is the reason for the clause. Maybe Mplayer has been lax about this? It is usually hard to find and rectify such slips.
Kjella
Live today, because you never know what tomorrow brings
He copies _ALL_ your code (which he's entitled to do under the GPL) and you question whether you can copy _some_ of his code back? I think the answer is pretty obvious. And if he doesn't like it, tell him he's bound by the licence that allowed him to take it in the first place, meaning not only can you copy his work, but he has to make sure it's available to you ON REQUEST as well!!!
I think you should make a third project with the common codebase :)
gtkaml.org
and not resort to name-calling. we haven't heard the other guy's side.
post ur opinion, agree with this mcwizard or the other guy, but let's not start calling people you haven't met or listened to names like idiot or refer to the size of his penis. and my threshold is 4...
if ever i'm in an argument, particularly if i'm losing, I guess i should ask slashdot before my 'enemy' does and hope for a response like this (i'm not implying mcwizard is the bad guy, just an example)
i was happy to see so many ppl uphold the values of GPL but was extremely disappointed when the insults began and snowballed
we're talking about ethics here.. aren't we? is it ethical to look down on ppl when u've won an argument about ethics?
that said, i must say i agree with most of the responses.. mcwizard is not doin anything illegal or unethical
Consider the fact that the spinoff project took all the code from your project, and that it's all GPLed. You should make the other project leader aware of that fact.
The GPL is all about sharing and reusing code. In fact, it effectively makes "failure to share" a sin. It's one of RMS's core beliefs -- and one of mine -- that there should be no such thing as closed-source software. When all software is Open Source, then there will be nothing to prevent any end being achieved by the best means possible -- because whatever the "official best way" of doing anything is, it will be shared by all. {What if Microsoft discover a security flaw in IE but decide to cover it up rather than patch it? Tough. You'd better hope no crackers find it by accident. What if the Mozilla Project discover a security flaw in Firefox but decide to cover it up rather than patch it? Sooner or later, some independent hacker is bound to discover that same flaw by looking at the code, release a patch, and nobody will trust the Mozilla project ever again.}
The original project was subject to the GPL. Unless the spin-off was started by the principal copyright holder in the original work, or was sufficiently different to be considered a new work in its own right rather than a derivative, then the GPL still applies to the spin-off and all its derivatives -- and will continue to do so until the original work enters the Public Domain, either through lapse of copyright or by court order.
Since the spin-off is subject to the GPL, then you have explicit written permission to copy it in whole or in part and to make derivative works subject to certain conditions. As long as you abide by those conditions, you are acting in accordance with the original licence. In fact, the permissions granted under the GPL are granted by the copyright holder, not the distributor. So if it was your original project, then nobody can stop you distributing it!
Je fume. Tu fumes. Nous fûmes!
As everyone else have said, legally there is no problem, and from a rigid ethical point of view you are also in the clear. Especially if the other guy is not the original author.
However, this misses another point which is also very important, namely how to create an athmosphere of cooperation (or at least peaceful coexistence), which will benefit both of you. Or more specifically in this case, how to teach the other guy the value of sharing.
If you say "fuck you, the GPL gives me the right to copy your code!", you can be pretty sure he will do his best to obstruct your work, and won't release any code again under the GPL (or any other free software license) when given a choice.
And given that he actually does write code worth of copying, that would be a loss for the community.
If you can give the impresion that you respect his wishes, but hope that you can find an arrangement so that you can incorporate his excellent work in a way he doesn't find unfair (maybe after an official release), and if there is any of your humble work he might find of use, you would be flattered to help make it accesible to him, and are there any other ways you could cooperate...
The instinct of most of us is to stand proudly on our rights, but often better results are achieved by looking at what you really want to achieve. Is being "right" really your end goal?
That will have the same effect as closing the CVS repository, only more so.
I am trolling
I work for a primarily FLOSS company. We recently developed an application which we were pushing at trade shows all over Europe. During our travels, we met several other companies' suits who were developing similar or identical solutions. Even though some of these companies are direct competitors, we encouraged them to look at our code, see the solutions we had created and adopt some of our code. Result: Out of 22 companies we talked to 20 made their solutions OSS. We have now integrated some of their code into our own product just as they have used our code. Moral of the story: Sharing makes the community stronger, eliminates much inefficiency and makes the software better! We survive separately BECAUSE we have different ideas of how features should be implemented.
--cros13
McWizard is the original author of MegaMekNET, and urgru has coded lots of stuff for it. McWizard wants MegaMekNET to cater to one set of players, ie. one online campaign of BattleTech, while urgru wants MegaMekNET (now MekWars, the fork), to be a lot more configurable for different server environment's needs.
This is probably the most redundant post I've ever posted, but I just have to state that I don't think that what you're doing is the least bit unethical.
To me, this is the whole point of the GPL. The end result is a better piece of software for the user, and that has to be good.
If somebody decides that your code is good enough to "steal" (in the GPL way), you should feel honoured, not angry!
May we live long and die out
Best example I know of (because they're programs I use): .com was first... .org thought it was unmaintained... patched it up and forked it... .com came back on the scene... Took some platform detection from .org and added a new "better" randomized memory checker... .org took the new better memory checker.
:). They seem (at least from an outsider's view) to at least respect one anothers' accomplishments. I use them both. Sounds like the asker is in a similar code situation, but the memtest* guys just know how to play nice.
www.memtest86.com
www.memtest.org
That's about all I can follow from the FAQs and ChangeLogs
-Tom
Both projects are GPLd.
Not only is it ethical to copy back the code; this whole community thing of having other people contribute directly or indirectly to your code, is *the point* of GPLing it. NOT allowing others to do this would be unethical.
Here's to the spinoffers: don't be a bunch of childish hypocrits. By making a spinoff of an existing project you benefited from the code of others, now give back something and let them benefit from your code.
Visit http://ringbreak.dnd.utwente.nl/~mrjb/growingbettersoftware to download your free copy of the book
Re your sig: the phrase is "couldn't care less".
Bad analogies are like waxing a monkey with a rainbow.
Who ever heard of a coder with anti-social qualities.
I have code written by myself. I wish to share it with others in case they find it useful and I have been thinking of making it GPL. However, what I wonder is the following. Consider that I make it GPL on 2005-01-01, then continue to improve my own code without anyone else is adding to it, then on 2005-12-01 someone adds their first contribution. The code pre 2005-01-01 is non-GPL so that I could make proprietary, but what about the code up until 2005-11-30? Do I give away all my rights to the code when making it GPL? Does the GPL say anything about this? What about LPGL? A similar idea is that what if I want to keep a main thread that I work on and maybe make money off one day [I need to have some income], but I will allow anyone else to *fork* from. So in summary, what license can you use if you wish to make money of your code, but at the same time want to share the whole or parts of your code?
It's just spreading FUD about open-source. Don't fall for it people! It's a troll!
Sounds like the Windows XP Service Pack team are poaching from the Longhorn team again.
""Yesterday, I was contacted by the leader of the spinoff project who told me that he's quiet angry at us for doing that and that it's considered unethical and rude"(snip)
Tell him he didn't fucking think that way when he started his OWN project by copying 100% of the code from YOUR project.
He's being unreasonable and the best thing to do is to ignore him.
He didn't mention it, but here's the project
t /
http://cvs.sourceforge.net/viewcvs.py/megamekne
It will not allow a developer to check in code that breaks things, you can fully attribute your code (who did what) and it will make you a happy bunny in general. If you don't want to be a happy bunny in a general that is fine too.
This space is intentionally staring blankly at you
...I've seen similar complaints about mplayer vs xmms, and quite a few other "competing" projects. In most of the cases, it has been about taking all the hard back-end work, and slapping a new GUI on top promoting it as "their" product.
At least in some of those cases it had merit because they are competing for developers, public support, financing, brand recognition etc. etc. But this looks more like a good old personal disagreement.
His project will not be lessened by you taking his improvements. If he feels you're leeching off his project (i.e. providing nothing in return), that is his own fault for not using any of the possibilities the OSS licencing provides.
There's nothing wrong or unethical with not wanting others to use your code. But you can't eat your cake and have it too. He took the GPL code, and he's bound by the GPL. If he wishes the licence was different, he should not be blaming his mistakes (basing his fork on a GPL project) on you. Who put a gun to his head and forced him to release it under the GPL? Only himself, by making it part of a GPL project.
Kjella
Live today, because you never know what tomorrow brings
Practically everyone seems to be agreeing here.
Must be the Christmas spirit and goodwill.
FORK OFF! Baaaaaahahahahahahahaaahaaahaaaaa!
Well, for my experience, this happens a lot more than the desired. I am the project administrator of a Open Source RenderMan compliant renderer. When I announced the development and upcoming release of my rendering system, the project administrator of another RenderMan compliant start complaining with it. Frequent questions in several forums ( and to my e-mail )was: " Why another OpenSource renderman? "; " Isnt the aim of Open Source avoid double efforts? "; and that sort of things. Hell, Open source does not restrict you in any way. You are free to think, why you shouldnt be free to develop your own project, with the characteristics that you want? The point of this reply is only to say that unfortunatelly there are a handfull of so-caled " Open Source Developers " that are only in this because they believe that is very cool to feature a Open Source banner in their websites.
If I'm understanding this right, someone forked a GPL'd project, but they're now claiming that the original project is being unethical in back-porting changes from the fork? That's crazy! Surely the whole point of the GPL, as opposed to say BSD-style licences, is that if you take GPL'd code you have to give back what you build on it? I don't see how the spin-off project have a leg to stand on, either morally or legally.
On the subject of obfuscation, it seems clear that they only have to give back the "finished product", and aren't under any obligation to allow access to development code. However, attempting to obfuscate the code given back also seems to be obviously contrary to the GPL, so the worst he can do once he makes a release is obfuscate the changelog as he suggested, which any decent diff tool will overcome in seconds for the original dev team.
Really, this just seems like exactly the kind of ego-promotion the GPL was intended to prevent. No-one forced them to take GPL'd code as the foundation of their spin-off project, but if you're going to take someone else's code, you have to do it on their terms, which in this case means "licensed under the GPL". If you don't like those terms, you're free to write your own code and release it under whatever licence you like...
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Reminds me of some people on wikipedia who get upset because "their" articles were changed, missing the entire point of wikipedia (once you submit, the text no longer is yours but is the whole community's).
Getting code from other GPL'ed projects, spinoffs or not, is not only not unethical, but is part of how the whole friggen thing works in the first place.
And how others have noted, they started *their* project by taking code from *your* project. So WTF.
The following sentence is true. The preceding sentence was false.
Basically you're right, but both McWizard and urgru use MegaMek in their respective projects. McWizard and urgru both do not do any coding for MegaMek.
That's not the point. MegaMekNET is as configurable as Mekwars, or can be made as configurable in a few minutes. One difference is, that the focus is on the main Server while accepting patches for other server, but not intentionally coding stuff to support others. That's because the player base is imho still too small to open up X other servers, but if someone wants to, he can do that of course. There are game related differences that make up the real difference between the two projects.
I think the guy who forked has more issues then you. Even though forks may split direction there are often places where they might make the same turns. Say with your graphics. So the guy who forked the code wrote a better graphics routine then you did. So you decided to use it, being that he got credit for the work, and he is not getting paid anyways he should be happy, with you using his code, it gives some validity to his fork. Just because he is angry it isn't your issue, it is his, For whatever reason for him forking he probably feels that he in direct competition with you (although it is not really a game, and there is no real looser) so when you use his code it feels like you are cheating.
If something is so important that you feel the need to post it on the internet... It probably isn't that important.
Merely agree that the leader of the other project is correct. Then ask for removal of all the base code that was copied from the original branch. Then ask what the difference is.
I remember reading about similar problems between JBoss and Apache Geronimo -- in that case, it was not so much a fork as Geronimo's using some JBoss code to fill in parts of Geronimo that hadn't been written yet.
Reusing Open Source code is not only legal and ethical, but it's the whole point of Open Source. My only problem is that I prefer to put my own stuff in the Public Domain, but if I borrow any code (rather than just referencing a library), then I have to follow that code's license. Sometimes that leads me to write my own simple modules instead of reusing existing ones.
If both branches are GPL'd (or close enough to GPL that such code sharing isn't legally opposed) and someone gets annoyed about code sharing, then I think it's time for someone (the fussy party) to grow up and learn to revel in the fact that "the best parts" get propagated.
If the code un-forks later because all the real innovations got accepted by the original branch, that might or might not be better. It might also be a sign to the keepers of the original branch that they should have accepted more of that group of people's changes earlier so they didn't feel they just had to fork or be ignored.
cheers...ank
Still hoping for Gentle Treatment...
The GPL does NOT take ownership of it.
I own everything I do.
The GPL just limits what I can do with a combined product.
This is specifically why Linus doesn't own the copyright to the whole kernel. It would be very hard to hijack it since there are many owners who would need to give permission.
mod parent up, seriously
Sounds like the other guy is having tantrums about nothing. Surely it's a tribute to the originators that others want what they have done!
Taking what's best is the power of freedom in software.
I don't believe the license is the issue here. GPL basically means share, share, share. If it were simply a matter of "can we...?", then the answer is yes. So, to look at the ethics, let's put it this way: They are altering an entire code base which was handed to them, so if they don't like the idea of giving back to the hand that fed them, they should look into being bankers rather than developers. Some posts above make a good point about perhaps the fork was forked because ideas were being ignored, but I have trouble believing their "vision" was a matter of 20 or so lines of different GUI code. IMO, you are more than welcome to anything they code, and vice versa. Everyone should grow up, shake the capitalist view of computer programming when dealing in the open source world, and learn to improve their software by monitoring similar projects for useful ideas. (My only exception is that, of course, if the only reason a project gets forked is to make minor changes and try to get to version 1 first, maybe those efforts would be better spent contributing to the original project rather than a childish race.)
========
77 77 77 2e 6d 65 6c 76 69 6e 73 2e 63 6f 6d
Simply promise him you'll remove all of his forked code from your original if he removes all of the original code from the fork.
:)
Problem solved!
The samba-tng project forked because of disagreement over how the samba team was handling a core design decision (named pipes). Samba-tng became capable of serving as a windows PDC, and the samba project took whatever code looked good. Relations between the groups have been strained at times, but their experience sounds like a pretty close parallel to what you're seeing.
At the end, though, GPL code is GPL code. If it's under the GPL, you can use it, and there's really nothing the author can do. I think most people would agree that the's nothing wrong with using open source code - That's what it's there for.
Ideology breeds Hypocrisy. Just how much is up to you.
First off, this is a post purely about what is allowed under the GPL - I'm not commenting on what's covered by the spirit of open source development.
The post said Nevertheless he's thinking about obfuscating his changelog and only open the source as packages when he's doing a release, which is, as he says, his right under the GPL
A lot of people have spoken about software being written under the GPL being open source and available to others. However, as I understand this case from the quote above, the original poster is talking about using code not released by the forked development, but generated during the development process that may or may not end up in the final version.
However, the GPL applies to modified code that is copied and distributed. Please see this quote from the GNU GPL FAQ (sorry for the TLAs).
If you commercially distribute binaries not accompanied with source code, the GPL says you must provide a written offer to distribute the source code later. When users non-commercially redistribute the binaries they received from you, they must pass along a copy of this written offer. This means that people who did not get the binaries directly from you can still receive copies of the source code, along with the written offer.
As an example, if I write an application based on an open source software project, but do not distribute it, I have no obligation under the GPL to release the source code for it.
However, if at a later stage I did distribute it, I would have to make the source of what is included in the release available, but not all the code in my repository, for example, unused classes and test harnesses.
So to conclude, I think that the second manager was legally within his rights to obfuscate the code being used during development and only provide source code at relase, as he threatened.
A personality conflict of that sort can really cause a problem but it doesn't mean that the two can work together... they just chose not to.
However that doesn't mean that a split is a bad thing... and I suspect that one day, if the two applications are similar enough they may get reintegrated... so IMO your just a step ahead.
I suggest that not only do you use the code, but give clear and obvious credit to the fellow who wrote it, not just hide the note down in the source but add them to the "credits" dialog for your app.
Indeed. That goes both ways, too. The forker could apply a little enlightened self-interest here. If the original maintainers are willing to go through the effort of considering his changes and merging them back where applciable, he shoudl be glad of the insurance policy. I don't think that both of these projects will survive: they are similar enough that almost everyone will eventually gravitate to one or the other. The determining factors are likely to be: which maintainer is more pleasant to deal with and which direction eventually shows itself to be superior. If it is the former and it is the forkee that is the jerk then eventually all the developers will come to his camp. If it is the former and the forker is the jerk, then it might be nice to have an alternative in case he finds out that being a project maintainer isn't for everyone. If the forkee believes (as he appears to) that his team's work is simply superior to anything the original group does, then again, his fork will "win" in the end. In the meantime, he has a the other project as an excellent source of useful fixes and ideas. OTOH, if his fork turns out to have been a poor choice technically he, again, has the other project to return to.
I could be very wrong here, so maybe someone could clarify the GPL on this issue.
Do the people paying the bills want you to duplicate efforts? Nooooo! He is doing a lot of work and you are improving your product from it, whoop-ie. That is part of being on the bigger team. If he does not want to be part of the team, he should be allowed to take his ball and go home. Then he can play with his balls all by himself. Go up the food chain until you get a non-techie, have a meeting and see what the answer is.
As you can read, pretty everyone say it's legal and ethical. I won't argue about this.
What I will say is that this kind of stuff is a good argument for a developer NOT to go GPL.
A lot of GPL projects ask for donations. I don't know if it actually works, but let's say that developer X has the OSS spirit, work very hard on a cool project, he even manage to bring a couple of other developers.
Then, developer Y forks the project, slaps a new GUI on it. Developer Y has better marketing skills, and forked project actually becomes more popular than the original project.
Now let's say that the forked project has a donation button, and it actually works. Where does that money go? 80% of the forked project code comes from developer X. Will developer Y send 80% of the donations he receive to developer X?
I seriously doubt that the majority of people clicking on the "Donate" button actually check the whole CVS changelog to check who actually contributed to the project.
If I'd be developer X and would see that happening, I would sure be angry, but everyone would say that developer Y is legal and ethical and they would be RIGHT. Thus, I would not be angry at developer Y, but at me for choosing GPL.
Cmon, flame me for not having the "OSS spirit", but I will not make the mistake of investing considerable amount of my precious time into GPL so someone else makes money off it, and this story is yet another reason against GPL.
That said, I am not really "against" open source. I use a couple of open source programs daily, and if I had the time, I would probably try to contribute to my favourites (TortoiseCVS, wxPython/wxWidget). I'm just saying that someone who expect a reward for his/her work on a GPL project is a fool, and I'm also saying that I'm skeptical about donation buttons.
The only project I donated to yet is crimson editor, and it's not even OSS. However, I can be sure that my money went to the developer who worked the most on the project, because there is only one. If the project would have been GPL from the start and had a lot of contributors, I would probably wouldn't have donated, because the money probably wouldn't have gone to the developers who worked the most.
perception is reality
Yes, but there seem to be an awful lot of cretins who will say "could care less" and confuse me.
I am trolling
I have a very strong opinion in this.
The fact that this guy is pissed off for other people using his GLP'ed code, proves beyond reasonable doubt that he doesn't even understand the basic principles of open-source software.
In reply, ask the man why he took GPL code to begin with. I'll bet my left kidney that he doesn't have a clue why. "Stealing" from a spinoff is no different than "stealing" from any GPL'ed project. If your resulting code is GPL as well, it's okay. That is the MAIN purpose of the GPL, and if he doesn't like it, just tell him to get his act together and hire a programmer to do a closed-source version of his present GPL code. Then he'll be forced to ask himself what his problem is. The truth is, it's not a problem, it's just good'ol fashion much ado about nothing.
It's just hipocracy to create a spinoff GPL code, and then complain when "the wrong person" actually bothers to use the rights given to him through the GPL.
Just tell the man to "RTFM", the GPL, in this case.
They took the entire codebase to make a spinoff, and you're worried about backporting the little stuff?
Don't sweat it.
The thing is that this is all irrelevant.
The simple nature of GPL'ed work is that *THIS IS WHAT IS SUPPOSED TO HAPPEN*.
Once you get a fork, the two projects will continue to evolve separately, but as they are attempting to solve the same problem, will probably end up merging again.
If the split happened because of differing views on the way to solve a problem, then it may take awhile, because they'll have to wait for one way or the other to prove that it's superior - at which point features from the other version will be gradually merged into the other, and the inferior design will be abandoned.
If the split happened because of personal issues, then it will happen sooner rather than later, because there are fewer technical issues - all you're waiting for is for everyone to cool off and start focusing their energies on the project. If it's because of one person, that person will eventually get overruled, and either learn to live with it, or quit - if it's a single developer, his/her code will be absorbed into the other fork.
The bottom line is that there is no moral/ethical issue here, this is a normal part of two healthy GPL'ed projects.
If that still doesn't work
Step 3:
Post an article entitled Free Pr0n for the Masses and add HIS site as a link. Let slashdot sort him out.
As far as relicensing goes, you have no problems until the first patch from a third party is committed. So in your example, the code up until 2005-11-30 is yours to do whatever you want with. And it remains so until copyright runs out (in Disneys dreamworld: forever). The code from 2005-12-01 and on is the only thing you do not have complete control over. But even then you might be able to keep a clean branch if you wish (use a good revision control system). Divide your own changes into two piles: ones that work without changes you do not hold the copyright to, and those which needs (including recursively) the contributions of others. I definetely ANAL, but I think that you could resonably easily argue that pile one is yours to license as you see fit (assuming that you are careful (rewrites of outside patches, and stuff directly inspired from them, needs to go in pile two as well. Basicly anything you are not absolutely sure is not derived)). Question is if pile one will be big or small, and that depends on lots of things, but first and foremost what patches you accept.
One way to do what you want is to GPL, but only allow patches assigned to you (like GNU does). That might spawn a fork, or lessen the number of patches, but if you do good work and announce your intentions up front (e.g: Explain that you intend to sell licenses to finance development of the Free side, promise to keep the code Free (only if you can live up to the promise!), provide good service to GPL users, and so on) there might still be some sucke^H^H^H^H^H helpful hackers out there (I hope that time will show the "suckers" part to be fun (as intended), and not a prediction).
Another option would be to carefully (and in the open, documented) setup your project as several seperate pieces, licensed differently. This might need a lot of thinking (perhaps even someone with legal expertise) to hack together, but but if you are careful, and _upfront_, about what is Free and what is not (and perhaps even why!), you might be able to create a good setup. One example could be to release content for a game seperate from the code (like Id with Quake).
Live by the GPL, Die by the GPL.
Comment from the fork maintainer is here.
Bryan J. Casto
bryan.casto(a)gmail.com
ignore him, he's a forking idiot.
go read up on how openbsd forked from netbsd - and watch how both camps take stuff from each other with no issues (eg, openbsd recently got netbsd's MP, and netbsd recently imported openbsd's pf). And don't give me that typical slashdot rhetoric about how openbsd and netbsd have different goals and are therefore not competitors - that's only spouted by those who haven't bothered to use both, and, usually IMHO, either.
This is open source after all. Part of the point is that different projects can take advantage of code generated by other projects. That the other project in question happens to be a fork of your own simply says the likelihood of relevant useful code flow in both directions is higher than usual. All benefit and none are harmed. That's about as ethical as it gets.
I don't understand how a person makes a project GPL and then does not want to share (or just share at some times). Then this guy is not really thinking about helping his fellow programmers. Maybe he is just doing it for the recognition among hacker circles.
Anyway if I was doing the project in the view of making a project that would help me and my nerd friends, I wouldn't see why I wouldn't like to help another person.
It is not unethical and the changelog guy is the one who is wrong, not the guy who started this thread.
politely remind him that his entire codebase was forked from your codebase. also politely tell him to fuck off