I thought I had achieved the desired. One of my open-source projects began to recruit a small audience of followers on GitHub. No more nagging insecurity, because about a thousand star watchers are following my project - that's all that is needed to confirm the value. This is something that can be remembered in moments of uncertainty. A reminder that I really achieved what I’m really worth. I never thought that the stars could turn away from me.

* * *

Everything happened because of one of the very people whose opinions I so diligently collected. I'm talking about one particular person who used my project to manage the backend data repository on his company's platform. It was a critical function, and as the technical director of his company, he was responsible for its technical soundness. He very professionally invested in the direction of my development. His project was very different from most others, where my code was usually used for third-party or amateur tasks.
')
His expectations from me as a maintainer and my own belief in my desire to share code - a combination of these two factors led to a rather incredible series of events, which I will tell you about.

Your idea is nonsense.

I hate requests for new features. I must either give reasonable reasons for rejecting the request — explain how to use the existing APIs to complete the task, or do the work to implement this function (if I'm an honest guy). In any case, requests for new features make you work.

In most cases, if the request is rejected, a short explanation is sufficient, and the topic is closed on this. I was so used to such dynamics that if someone suddenly challenged my explanation, then this shit immediately fell on the fan.

Let's go back to the guy I mentioned. Previously, he made two pull requests - one removed the quotes from the aliases of the SQL tables, and the other changed the scheme by which aliases were generated. Both patches were problematic. The first required maintaining a list of all SQL keywords and checking whether the alias matches the keyword — and using quotes only in this case. The second was purely cosmetic, affecting how requests are sent to the database (it is always hidden from the user and specially rendered to the level of abstraction by the library). I explained the problems of the patches as I understood them, and rejected them.

The next bug report from him was no better. In this case, he tried to join the same table twice. I explained that you need to use a specific API for double reference to one table. I started to get angry.


Unfortunately, I did not keep the original text of my message before editing, but it was not very polite. Well, what the hell, we're just people.

A couple of days later, a new development ticket appeared. Now he believed that a particular API should behave differently. I showed him a place in the documentation where the API behavior was explicitly described. He answered the following (highlighting it):

the fact that the quirkiness of the API is documented does not mean that there is no room for improvement. and I have not seen the documentation / descriptions why you like such an architecture solution, and not other alternatives.

Our relationship reached a new level, where my architecture decisions were not only disputed (or openly called wrong), but I was given the responsibility to protect them. There can be no courtesy.

This level was about expectations . He felt that they owed him, and I felt free from obligations. I expressed my indignation and indignation to him, after which we entered the last, most destructive phase.

Closed question with extreme prejudice

I stopped responding to his tickets. Sometimes I deleted them (and if I could not, I clicked “edit” and erased all the text). Sometimes in indignation I asked who he imagines himself when he comes to the tracker and demands explanations from me on those aspects of my library with which he does not agree. In the end I banned it on the project.

At some point, he edited the project page on Wikipedia, added the “ Controversy ” section there, which said that I maliciously banned project users and refused to discuss technical issues. He also launched a sprinkler campaign on Twitter / HackerNews / Reddit / Wikipedia, in every possible way bothering me and the project. It was a damn madness. I ended up asking the Wikipedia staff to delete the page of my project. Did I say it was damn crazy?


In these comments, he mentions the situation after he was banned, and one of his colleagues began to make comments in the same tone.

Allegedly, I am targeting my own users and deserve condemnation. For his hard work, the result of which is laid out for everyone? What the fuck, I thought. No, well, really!

Who is treating whom?

He was absolutely convinced that it was me who was to blame. The project itself and the tracker posted on GitHub were a common fair platform for any discussions. When I deleted some of his comments, I was greatly impaired by his freedom of speech. I also showed my true face: a petty tyrant in the tiny kingdom of code, so he did a noble act warning the others about it.

Of course, my opinion was the opposite. I wrote the code and, to help others and improve the library, put it in free access. The fact of publication on GitHub does not give the project some special status, in my opinion, except that it is just a convenient platform for hosting and analyzing code, with a tracker. In the end, my project. I licensed it in such a way that no one is forbidden to take the code and change it according to my tastes (this is exactly what he did in the end).

In truth, we both could behave more politely. I am sure that he was hurt that he spent time preparing tickets with a description of the problem, and they were closed without sufficient discussion. It was unpleasant for me to argue with me in such a tone as if they had the right to do so - I say that, because at that time I thought that the library was completely in my possession.

Cui bono

Another way to look at the situation is to see who benefits from the publication of the open source project. Ideally, this is equally beneficial for both end users and the maintainer. End users (one of whom is the maintainer himself) get a continuously improving product, and the maintainer plus can add another good point to their resume (or a warm feeling of support from outside). I began to wonder, maybe I'm not doing the right thing?

I like to think that I am acting in the spirit of Ben Franklin, who wrote:

If we willingly take great advantage of foreign inventions, then we should be glad of the chance to serve our other invention, and we should do it disinterestedly and generously.

But were my intentions so pure? No, not at all. As I said before, this project has become a kind of intermediate stage; a way to understand yourself as a developer, and from there - as a person. In the end, it was an amateur project. Creative expression. The thing, the form of which spoke something about me as a person, what I am standing for, which I consider correct.

And here comes the guy who makes me protect things that he doesn't like or that he thinks are strange. In the end, I think he was more right than I was willing to admit at the time. He expected to discuss his ideas according to their merits, and since the project did not clearly indicate that this was my hobby, he could well ask for a place at the table as an equal. He did not receive it, and I repent that at that moment I did not see the situation more clearly.

I am sure that something similar would have happened earlier if another person who had invested a lot in the project, but who had his own ideas about implementation, would come and start making changes.

This whole situation made me more closely monitor my motivation when working on open source projects. I was keenly aware of how important it is to find a balance between the trust of users to you as a maintainer (according to any statements you make for your library), and between not jeopardizing the conceptual integrity of a project when they ask for a change.

This experience has also shown that retaining ownership can be difficult in open-source. If the project code is published under a free license, does it belong to its creator? Or did he get a life of his own in which users must protect him like the one I met, even if it means cutting off the creator? Isn’t this the reason we have permissive licenses and the Fork button?