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
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!
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?
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.
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?
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.
dang, meant to say "hate" there...
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.
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
Oh, that already happened.
If you have a good reason, just split the code - emacs survived it, XFree86 survived it.
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. =====
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
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.
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.
...except that when you take out that piece of pie that your spouse was saving, there's still as much pie left in the fridge.
In a code split, stuff gets split 100-100.
Everyone is entitled to his own opinions, but not his own facts.
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.
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.
Furthermore you have the issue here hypocracy. Obviously one branch seems to think it is OK for them to use a common codebase developed by the other side, but not OK for the other side to do the same thing.
If the guy doesn;t want to allow you to use his code, he shouldn't have used your code in the first place. What strikes me as particularly unethical here is that he used the common code base but did not want to return the favor, despite the fact that this use was dependent on such permission (the GPL). So in the end, this guy (the one who doesn't want to share his code) is essentially stealing by his own account and by his own standards. This is unethical by any reasonable standard.
Again I think it is appropriate to use whatever code you want provided that you have legal permission to do so. I don't see any ethical issues because reciprocity exists.
LedgerSMB: Open source Accounting/ERP
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
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.
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?
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.
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.
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
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
Ah, but the GPL is also an ETHICAL document. The purpose of the GPL is to share code. It's not merely that sharing code is *permitted* by the GPL, but that it is *encouraged* - indeed, prescribed by the GPL. The purpose of the GPL is to disseminated shared and reused code, and obfuscation and claims of "code theft" are in direct opposition to the moral basis of the GPL. In other words, you're comparing a prescription to a proscription.
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?
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
you're confusing a side effect of the license with the spirit of the license.
The difference between the GPL and BSD licenses is that the GPL enforces the spirit, that doesn't mean that BSD doesn't have the spirit of freely available and shareable code at its heart.
Advanced users are users too!
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.
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.
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!
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.
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.
I'd suggest replying to the guy with a limerick:
Do not look into laser with remaining eye.
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
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.
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.
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?
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
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
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
Who ever heard of a coder with anti-social qualities.
...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.
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.
If you can't make a closed fork, then many people who would otherwise want to make one are instead motivated to either contribute back to the main project, or not use it at all.
You can't contribute if the committers aren't interested in your patches and won't put them in CVS. Most of the time this is due to a quality or style issue, but sometimes it's just due to the fact that the committers might have another vision of the project than you do. In a case like that, where you are quite willing and able to do the work, you have two choices: patch every new version with your changes or fork the project. If enough people value your choices you might be able to develop a viable fork.
Although forking should never be undertaken lightly, it is the sine qua non of freedom in software.
#!/usr/bin/english