Title: Opensource from an author point of view
Author: Solène
Date: 23 March 2021
Tags: opensource
Description: 

Hi, today's article will be a bit different than what you are used to.
I am currently writing about my experience as an open source author and
"project manager". I recently created a project that, while being
extremely small, have seen some people getting involved at various
level. I didn't know what it was to be in this position.

Having to deal with multiple people contributing to a project I started
for myself on one architecture with a limited set of features is
surprisingly hard. I don't say it's boring and that no one should ever
do it, but I think I wasn't really prepare to handle this.

I made my best to integrate people wishes while keeping the helm of the
project in the right direction, but I had to ask myself many questions.

# Many questions

Should I care about what other people need? I could say no to
everything proposed if I see no benefit for my use case. I chose to
accept some changes that I didn't use because they made sense in some
context. But I have to be really careful to accept everything if I want
to keep the program sane.

Should I care about other platforms I don't use? Someone proposed me to
add some code to support Linux targets, which I don't use, meaning more
code I can't test. For the sake of compatibility and avoiding extra
work to packagers, I made a very simple solution to fix that, but if
someone wanted to port my program to Windows or a platform that would
require many many changes, I don't know how I would react.

Too much changing code situation. My program changed A LOT since my
initials commits, and now a git blame mostly show no lines from me,
this doesn't mean I didn't review changes made by contributors, but I
am not as comfortable now that I was initially with my own code. That
doesn't mean the new code is wrong, but it doesn't hold my logic in it.
I think it's the biggest deal in this situation, I, as the project
manager, must say what can go in, what can't and when. It's fine to
receive contributions but they shouldn't add complexity or weird
algorithms.

# Accepting changes

I am not an expert programmer, I don't often write code, and when I do,
it's for my own benefit. Opening our work to other implies making it
accessible to outsiders, accepting changes and explaining choices.

Many times I reviewed submitted code and replied it wasn't fine, and
while it compiles and apply correctly, it's not the right way to do,
please rework this in some way to make it better or discard it, but it
won't get into the repository. It's not always easy, people can submit
code I don't understand sometimes, I still have to review it thoroughly
because I can't accept everything sent.

In some way, once people get involved into my projects, they get
denatured because they receive thoughts from other, their ideas, their
logic, their needs. It's wonderful and scary at the same time. When I
publish code, I never expect it to be useful for someone and even less
that I could receive new features by emails from strangers.

Be prepared for this is important when you start a project and that you
make it open source. I could refuse everything but then I would cut
myself from a potential community around my own code, that would be a
shame.

# Responsibility

This part is not related to my projects (or at least not in this
situation) but this is a debate I often think about when reading dramas
in open source: is an open source author responsible toward the users?

One way to reply this is that if you publish your content online and
accept contributions, this mean you care about users (which then
contribute back), but where to draw the limit of what is acceptable? If
someone writes an awesome program for themselves and gather a community
around it, and then choose to make breaking changes or remove important
features, what then? The users are free to fork, the author is free to
to whatever they want.

There are no clear responsibility binding contributors and end users, I
hope most of the time, contributors think about the end users, but with
different philosophies in play sometimes we can end in dilemma between
the two groups.

# Epilogue

I am very happy to publish open source code and to have contributors,
coordinate people, goals and features is not something I expected :)

Please, be cautious with this writing, I only had to face this
situation with a couple of contributors, I can't imagine how
complicated it can become at a bigger scale!