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."
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
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.
Depends on whether both teams are more interested in politics or good software...
... 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?
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.)
I agree. Why bother duplicate the effort to write the same code between projects. Heck, open source projects should be encouraged to use each others code. That way some things could get done faster, and you already (hopefully) have some relatively debugged code that does what you want. This is probably just a matter of someone having an inflated ego.
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.
i don't think it should be an ethical problem either because development in any field should be considered a continuation where you should make only new stuff. if you have to start from scratch every time, then it will be a serious hindrance to development...
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 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.
Take the high road, continue to use the best available resources (even his code) and document and give credit to the appropriate people.
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
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.
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
In my opinion the open source community around Fire, Adium, Colloquy and Gaim is a good example of how things are intended to be. Fire and Adium are "competing" in the sense that they are both high-quality IM programs for Mac OS X, yet the developers have no problems collaborating. As mentioned in the parent post, a nice tabbed window controller was written for Adium, and was then adopted into both Colloquy and Fire. In the reverse direction, Colloquy's WebView-based message displays were adapted for use in both Fire and Adium. Gaim's service libraries have been factored into "libgaim" and are used to provide the core functionality of Adium, while Fire's AIM code is based heavily on Gaim's implementation.
;-)
Open source is about sharing work to prevent reinventing of the wheel. Occasionally it is still necessary to re-implement functionality that exists elsewhere, but in general it is more sensible to build upon others work than to duplicate effort.
"Good artists copy. Great artists steal."
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.
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.
In addition to the excellent above points, obfuscating the changelog also hurts his project. The true foundation of open source is the ability for Joe Coder to submit patches and additions to the project. He will limit others abilities and/or willingness to commit code to his project.
The unfortunate aspect of an Ask Slashdot like this is we don't know the other developer's story. The developer has probably missed the point of open source and he's might even be a complete jackass but ultimately he's not here to defend himself. He may have some points missed by the author by mere nature of author's own subjectivity.
That said, I'd keep on keepin' on. You are well within your rights to use code as long as it's credited. Furthermore, I think it's ethical and in keeping with the spirit of the GPL and open source culture to apply code that makes your application better. The point is to collaborate and make software that Sucks Less.
A fork from a GPL'd project is subject to the GPL. RTFGPL section 2.b for the specifics.
If the forker starts obfuscating his code, he is locking in his clients as effectively as if he closed the source. From what I hear so far, it looks like the fork happened because somebody got into a dick-size-war and started to lose. Now, he is trying to make his project better by attempting to sabotage your project. While he is not circumventing the letter of the GPL, he is violating its spirit by forsaking cooperation for his own glory.
Aside from the fact that he is, in effect, telling his users (if any are left) that he no longer gives a fuck about them, there is still nothing to prevent you from downloading the full source and running a diff to see what he's done.
To summarize: What you are doing is not merely ethical but encouraged by the spirit of Open Source. What the forker is doing is unethical, unsportsmanlike, and contrary to the spirit of Open Source. If he's true to the pattern of the Wounded Ego, he will soon threaten some sort of legal action against you. Ignore him. At this point, he has about as much credibility as SCO.
This is not my sandwich.
I agree with you, and it's especially true if the submitter is the project leader from the *original* project, not the leader of the spinoff. In that situation, it's pretty hippocritical for somebody to fork your code, and then scream at you when you re-incorporate his changes -- afterall, he started his project by stealing 100% of your code, presumably because he wasn't happy with it. He should be happy to see that his improvements are making it back into the original project.
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.
Some developers don't want their code taken and "locked" away in some proprietary app, while others don't care. I happen to go along with the GPL camp for the most part. If I give my time and effort to a community project, I don't want someone to be able to take that effort away and not have to give back to that community. Note that the GPL and people who believe in the GPL don't care about profits. If you can take a GPL app (like MySQL) and make money, so be it. Just don't try to take the code away.
The GPL is all about the code and the end-user rights to the code. Other licensees like the MPL, BSD, etc are not about the code or the rights of others with the code. The MPL and BSD allow you to take the code and derive from it and keep that derived code locked away. Again, some people feel that is OK and others don't. It all comes down to where you stand on that issue. I personally think both sides have good points, I just favor the GPL/LGPL for a stronger community. IMO, the GPL/LGPL foster sharing of knowledge better then the other OSS licenses. And to me, sharing of knowledge is the most important thing.
If Tyranny and Oppression come to this land,
it will be in the guise of fighting a foreign enemy. -James Madison
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.
According to *my* EULAs, I don't have any legal rights even when I *am* paying.
"Lawyers are for sucks."
- Doug McKenzie
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
That appears to have been answered already. Anyone who talks about "their code" in GPL software made up from code by many contributors has a problem already.
The fork can certainly hide its code until releases, but then it's got all the disadvantages of a proprietary software product - it's hard to work on and has no community. Plus when it comes out a little bit of diff and reading will deal with anything of interest. And obfuscate the changelog - as a user would you trust software whose author has made changes unauditable ?
If the fundamental design goals are different then the chances are that the opportunities for sharing will go down over time anyway.
Alan