[moron4hire]

I had a very similar experience with running open source projects. I was getting frustrated with people not contributing in any significant way. Functionally useless bug reports. Coding bootcamp students submitting PRs that did nothing but change some grammar in the README (and never actually changing it correctly). Feature requests for things I had explained in several other issues that I would never do. Requests for support in setting up other people's software.

But if people are contacting me about my project, they must be using it, right? Isn't that the point? Can't I just ignore the noise? What's the problem?

I eventually realized my motivations for developing open source software were rooted in vanity. Just making programs is something I do all the time, I find it very rewarding. But the part about open sourcing it, that was the vanity.

Before opening the project, nobody else was contributing anything to it, either. After opening it, all that changed was that my expectations for how people would react to it were not met. Expecting people to want to use my software in exactly the way I wanted was a hell of a lot of arrogance. Those people who were requesting features, they weren't "wrong", they just wanted different software. More like a service that did the things my software could enable, rather than building things with my software.

I don't write the software to get rich or escape a dead-end job. I used to have that fantasy, but nowadays life is pretty happy, and I also have realized the fantasy was always a myth, anyway. So in the end, the difference between writing software and writing open source software is nothing more than me wanting recognition for the thing I created; aka a vain search for glory.

I didn't like that view of myself, so I stopped opening my software.

[beachy]

> I eventually realized my motivations for developing open source software were rooted in vanity.

Very insightful, but is it in fact a slightly different emotion to that?

In the Mythical Man Month, Fred Brooks says:

> Why is programming fun? What delights may its practitioner expect as his reward? First [..]

> Second is the pleasure of making things that are useful to other people. Deep within, we want others to use our work and to find it helpful. In this respect the programming system is not essentially different from the child’s first clay pencil holder “for Daddy’s office.”

I don't know if this is quite vanity. That sounds a bit too negative. Is this the kind of complex emotion that Germans would have a word for but not English?

[moron4hire]

For the vast majority of people, a program being open source does not make it more useful to them. The program just existing is the useful bit.

Also, Germans don't have words for things. They just remove all the whitespace from their sentences and then run around, "look at this neues word Ich hab!" :D

[account42]

> I don't know if this is quite vanity. That sounds a bit too negative. Is this the kind of complex emotion that Germans would have a word for but not English?

I'd say the need for validation describes that closely enough.

[cubano]

> I eventually realized my motivations for developing open source software were rooted in vanity.

Bingo. The hard-earned wisdom of this insight right here almost completely explains all the internal issues the OP was feeling when he wrote his rather over-the-top post.

Yeah, it sucks to realize that your just as human as the next guy and that your motives aren't always as pure as you wish they were, but there is nothing at all wrong with being proud and wanting to be noticed for abilities.

Figuring out what path works for you AFTER realizing your motives aren't pure is how one solves the open-source user issue.

[travisjungroth]

You’re saying no one uses your software whether it’s open or closed, you just got annoying “contributions”. How did you know no one was using it? How would you know if someone was?

[moron4hire]

No, I didn't say people weren't using the software. I could see that in a lot of different ways: how many people were active on the project site, how many people had forked the project on github, etc.

My point was that my reaction to things like feature requests I didn't want to build was a signal that I wasn't interested in building just a user base for the project. If what I were interested in were building a project that people wanted to use, could sell to them, etc., then I would discard my notions about what I wanted to build and I'd build what people wanted. That was the epiphany I had. I realized I had been lying to myself about my motivations. I realized that my actions proved I didn't really care about getting people to just use the software.

Because I was so annoyed by the lack of contribution, despite the obvious signals that people were using the software, I (eventually) realized that my true goal was for people to interact with my code, not my program. There's a difference there. Any feature in a program can be implemented in any number of ways. But there's necessarily only one way that it's implemented in my program. Thus to be more focused on contributions than usage implies that I care more about how people see my implementation of the features than the features themselves.

I didn't start these projects thinking, "let me make a thing that will prove my prowess as a developer". I made the things to scratch some personal itch. The software on its own fulfills that particular need.

The act of open sourcing it was a different thing entirely. It's not trivial to open source a project; there's a lot of work in trying to prepare it for use by other people. Why go through all of that? What need did I expect opening the code to fulfill for me? Opening code doesn't attract users. So few users care if a project is open or not that they can safely be ignored as a rounding error. So why focus time on opening the code, verus any other action I could take with my time?

Thus the realization that I had been deluding myself.

[jka]

> Because I was so annoyed by the lack of contribution, despite the obvious signals that people were using the software, I (eventually) realized that my true goal was for people to interact with my code, not my program.

That's a neat observation. My theory -- hard to prove -- would be that if you leave the code open for long enough (regardless or not of whether you pay attention to contributions, and how many of them there are), you'll find some keen soul further down the road who finds and repairs some kind of compatibility issue, security/privacy problem, or similar.

> So few users care if a project is open or not that they can safely be ignored as a rounding error.

I can near-guarantee that for users who understand that software can do whatever it wants on their system, within the capabilities of the runtime environment and as instructed, then when those users are provided with the option to be able to see the corresponding code or not, they'll choose to have it available to them. In an enterprise context: it can sway vendor selection.

That's an increasing percentage of users today, I think. Perhaps it was the case a decade or two ago that people thought of software as windowed applications on their desktop; nowadays I reckon that more people have software developers within their extended social networks, and from that exposure they have a little bit more of a sense for how computers and code work.

And in response to one of your parent comments:

> I didn't like that view of myself, so I stopped opening my software.

Totally understandable. Don't forget the fact that you have an opportunity (not a responsibility, by any means) to teach and share code with current and future generations of developers.

They might discover some relevant snippet of yours through code search and find exactly what they need to solve a problem. Perhaps they'll credit you; perhaps they won't (perhaps they won't realize or be in the mindset that it's worthwhile (and/or important) to credit people for their work) - either way you'll have helped someone with their day.

[reflexco]

Some licenses may require build instructions, but if all you want is to open your source code so that other people can read it, you can just do that. Remove secrets, publish the code, and you're done.

People can figure out how to build it if they want, it's not your problem or responsibility unless you want it to be.

See Keybase or Signal for instance.