Title: Opensource from an author point of view

	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!