Slashdot Log In
Feature: Conflicting Open Source Developers
from the its-not-all-fun-and-games dept.
The following was written by a Slashdot Reader who wants this posted Anonymously
Conflicting Open Source Developers
I have a question for you, and a point for discussion. What "normally" happens to an open source development project when people writing code for it don't get along? How do open source authors deal with conflictswith other open source authors? Let me relate the story about my first experience maintaining open source software, as I think it's a pretty good illustration of this. I used to work on a program (for the sake of this discussion, let's call it P, for Program) that I volunteered to take over development work on around two years ago, after the original author produced version 1.0, and had no more time to work on P.
At the time I took over maintenance and development for the package, I had lots of time free at the business where I worked. My boss was understanding enough to allow me to devote a few hours a week of paid time to P, which I believe doesn't happen often for open source authors.
As time passed, our business grew, and I had less and less time to work on P. I managed to release an alpha version with some improvements, but some people weren't pleased with the pace of development. One of them took it upon himself to start work on his own version of P. For brevity, I'll call him Mr. J, for Jerk.
Now, normally I'd cheer this, since it's what open source is all about. However, it seemed what Mr. J really wanted was acclaim. I had released version 2.0 beta of P, based on the 1.0 version from the original author. Mr. J released a version he called P 1.2, also based on the original 1.0 code, with his own modifications. This generated a lot of confusion, at least in my opinion, since he had the same name for his package as mine, and similar version numbers. So, I asked him to please change the name of the package to something else to clear things up.
His response was to publicly declare that he should be named the official maintainer of P, since I was taking too long. I should note that at this point I would have happily turned over development to him, if I'd thought he could do the job well. I didn't think he could (putting it mildly). I'm going to skip over the discussion we had on the subject on the P mailing list (on my mail server) since it includes a lot of childishness on the part of Mr. J. Suffice it to say that things ended up with Mr. J calling me a few names, and vowing to take over P as part of a larger project he was working on.
Mr. J proceeded to take a copy of the names on my mailing list, and create his own list. He declared his version to be the official version of P, and ceased to take part in the original list I had set up. After all the argument on the original list, I was glad he was gone.
That is, until someone posted a question about my version of P to his list (which he had subscribed me to as well).
He took the opportunity to publicly call me a few more names, and make some comments about my lack of progress. I had had enough at this point, and mailed him telling him that I didn't want him to mention my name at all, ever again. I was hoping he'd start completely ignoring me, leaving me free to work on P quietly, without his interruptions.
Boy, was I wrong. Mr. J proceeded to mail me back and tell me that he would do whatever he pleased (again, putting it mildly). He also added a text description offering to let me perform an obscene act on him to his .sig file, which he used publicly on mailing lists and whatnot.
Completely appalled at this point, I e-mailed his providers for web space and connectivity, threatening them and him with lawsuits if he didn't remove my name from his postings. This got another nasty response from Mr. J, but eventually did get him to remove my name from his sig file.
This brings me to present time. I now have such bad feelings associated with the whole affair that I don't like to think about P, much less work on it. I've stopped working publicly on it, in fact, and I only do development on in-house versions that will never see the light of day.
My question for Slashdot readers is this: Is my experience common? How do open source authors deal with this kind of thing? Any suggestions as to what I should have done instead?
Regards,
John Q. Hacker
Why not work together? (Score:4)
The person who owns the code, and hence the title, was the original author, correct? And when he gave it to the 2nd guy, then the 2nd guy owns it. And until such a time that he gives it up, Mr. J can not claim that the code is his.
Mr. J should have renamed it, (say to NP) and mentioned that it was based on P... He could even mention that he started his own version because he wasn't happy with the other version.. that's fine too...
Of course, the mature thing to do would be to work together... to put the egos aside or to accept the credit as a team... Open source projects work better when there's more than one person working on it...
A plea (Score:5)
About my only contribution to open source software has been adding Solaris support [rgu.ac.uk] to XMMS [xmms.org]; I've put a fair bit of work into it, but others have been forthcoming with patches, modifications and rewrites. Nobody has tried to claim excess credit for work or tried to fork it off, perhaps because I've been willing to accept that (a) I am not a brilliant programmer and (b) others can do it better. Noone has insulted me or called me names (one person said the code was a mess, but I agreed with him; he was one of the coders who supplied fixes). In short, my only experience within open source software has been good.
Open source projects can be very successful; just look at Apache [apache.org], which has scores (hundreds?) of developers. However, the larger the project, the larger the requirement for a core developer or small core team to coordinate efforts.
In this case above, the maintainer perhaps couldn't devote as much time as he would have liked to the project (or as much as it deserved?) resulting in Mr J. trying to take over.
The world is full of jerks, and unfortunately some of them use computers. Try to make the world a better place by not being one of them.
--
Ironic but this is a great strength of Open Source (Score:3)
The very lack of a heiarchy of authority, and the freedom we all enjoy to take existing code and run with it in whatever direction looks promising, is one of the fundamental strengths of the Open Source paradigm. What the author described is one of the worse case scenerios for Open Source software -- two people competing for the same recognition, who loath each other and spend more time slinging mud at one another than they do productively writing code. The result? Two programs (P and P' in this case) which are competing for a user base. Both are improving over time. The following possibilites exist:
JHQ drops development of P, J drops development of P' -- If P or P' have merit, someone else picks up the project and it moves along, sans the bloody rhetoric.
JHQ continues development of P, J continues development of P' -- two compteting products exist for users to choose from, a benefit for the community despite the poisonous relations and rhetoric between JHQ and J
JHQ stops developing P, J continues development of P' -- a viable product continues to exist, and anyone who wishes may continue work on P as a competing product.
JHQ continues developing P, J drops development of P' -- as above, a viable product continues to be developed, and anyone is free to contribute or take over the development of P' if they wish.
In a closed source environment, subject to the heirarchy you consider so vital, there is a good chance similar internal bickering and politiking will result in unacceptable compromises in the code or direction of development, or even the scrapping of the entire project. At the very least one can expect delays to result from this kind of animosity in a corporate or closed source environment (I've seen it in both academic and corporate contexts). In that case, however, users loose even the possibility of obtaining a program they might have found useful. This cannot happen with open source.
In summary, open source removes limits on creativity, allows projects to move in many directions at once, and provides a built-in robustness to projects that allows them to survive some of the ugliest interpersonal conflicts humans are capable of devising. Name one other development model that exhibits such strengths.
Management (Score:5)
1) To determine the strategic direction of the software project.
2) To manage the personnel in your team.
The amount of code contributed by the project leader isn't so important. If people trust you to do these two tasks then you should be OK.
What has happened here is a crisis which is probably symptomatic of some underlying management problems. Here are some diagnostic questions:
1) How "Open" was the source?
Was there a cvs tree which could be accessed by others(not necessarly anonymous)?
Did you encourage submission of and discussion of feature requests by the users?
Was there a list of tasks to be performed for the next version that could be picked up by any keen developer? If someone is unhappy with the pace of development, all you need to do is point to this list.
2) How well managed was the list?
Was intemperate or rude language tolerated on the list, or was it gently discouraged? (I was once told off, privately, for using the word "crap". I am not kidding.)
How was conflict resolved on the list: by trying to reach consensus or by decree?
Did the users trust you to make the technically correct decision?
Par for the course (Score:3)
The only way to handle this situation was to break off the code base and develop P as a different product. Ignore the original developer. He was being unhelpful and did not want to help with efforts on the now splintered P.
So, is Open Source flawed because of situations like this? No. Open Source is a viable way to develop. It may take some thick skin to get through development, but Open Source gives us the right to develop a project our way. If anything, this is a prime example of the benefits of Open Source. The author could have simply spun off his version os P and left Mr. J behind. I am not faulting either party. It was a bad situation that could have been handled as adults, but was not.