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!