Context
Around a year and a half ago, I’ve asked my former company for some time to
work on an issue that was impacting the debugging capabilities in our project:
gdbserver couldn’t debug multithreaded applications running on a PowerPC32
architecture. The connection to the gdbserver was broken and it couldn’t
control the debug session anymore. Multiple people have already investigated
this problem and I had a good starting point, but we still weren’t sure in
which software component the issue lied: it could have been the toolchain, the
gdbserver, the Linux kernel or the custom patches we applied on top of the
kernel tree. We were quite far away from finding the root cause.
As someone who had a mildly unpleasant interaction with kernel folks, I can totally understand the issue.
This is one of the very few open source projects I had the feeling they don’t appreciate new contributers. There is no on boarding material available and picking the wrong subproject mailing list results in being ignored. You have to spend days without any possibility of help and if your are lucky you get mentioned as a reporter. For the next issue you start from square one as there was no guidance, so you could only learn the bare minimum.
So yeah, his patch may be underwhelming. But the help and credit he got for days or weeks of unpaid work was basically nothing. You may be okay with spending days and only getting credits for the bug report, but I suspect many aren’t and will not contribute again after such an experience. And post like this try to point out the issue they have and why many people won’t contribute to the kernel ever again.
Especially in this particular case the effort is in debugging the problem, not doing the actual fix - which is the bug report, where he got credited for. lkml is not the place for “how I debugged this problem” - that’d be what goes into his blog. And if you look around you’ll see a lot of “how I helped solving this problem” kind of blog posts.
This change is so simple that guiding him to do it in a good way would involve fixing it yourself in the explanation - and then you’d not show the code so he can do it himself? That’s just silly. If he cares about that he came out of that with quite a bit of experience on how to handle it the next time - and he mentions he even got an (assumed to be starter friendly) other issue suggested if he wants to have code in the kernel.
From the perspective of hiring people he turned this from a “nice work debugging a problem, might be a useful candidate” to “tries getting low quality code merged for vanity reasons, let’s avoid that guy”
I didn’t meant to defend the patch and I see your point. But I personally think that it’s not unreasonable to expect to land a bugfix commit after spending multiple days debugging a complex issue, that’s why understand that he feels robbed of a kernel contribution.
I don’t know what could have been a good solution for this scenario. But taking potential future contributors feelings more serious would help to keep them around and make them feel appreciated.
The shit storm he brew up in response to getting feedback on his very first pull request is way more concerning than churning out low-quality code.
Coding skills can be improved, specially from the first pull request onward. Toxic behavior such as putting up very public smear campaigns in response to getting feedback on his very first patch submission is a major red flag, and is as toxic as it gets.
That’s roughly what I meant - he should’ve come out of that experience having learned a lot (there’s even an explanation why the other code is better on the mailing list), and had the option of working on a different problem (while he didn’t say which I assume it was selected to be more beginner friendly). And instead he’s throwing a temper tantrum - that’s too risky behaviour for hiring.
We should keep in mind that this is a one-sided account on how a mundane bugfix issue was handled. Grain of salt required.
Nevertheless, the blog author said he received feedback from members of the Linux kernel security mailing list. Even though I think he could have received more credit than reporting the issue, that was basically his contribution: he pinpointed where the bug was. He also contributed a couple of patches that were faulty and unusable, and the maintainer had to step in and roll out his own fix.
I understand that fixing a nontrivial bug is a badge of honor, and getting credit for critical contributions might have more implications than a warm feeling. However, if the submitted patches were unusable then what would be the desirable outcome? I mean, should Linux users be deprived of a bug fix because a first-timr contributor is struggling with putting together a working patch?
Good point, this could just misrepresentat the situation. I also haven’t looked over the mailing list thread and comments here are very salty.
But giving him the benefit of doubt of a nice potential contributer who just debugged a very hard issue and sending in a basic concept of a potential fix. I think it would be beneficial for their community to take the wish for more credit more serious and try to make him feel welcome. But I recognize it was probably hard to do in this case.
Overall I just wanted to recognize that I do see how he feels robbed of his contribution. It reminded me that I also had an experience with the kernel developers that made me not want to contribute again.
I think they did. Apparently the maintainer trusted the first-time contributor enough to propose tackling another bug.
If the goal is to get more contributions, I think that’s exactly what should happen. I feel the kernel maintainer is being treated unfairly.
Whining about getting extra work feels like the author didn’t intended to contribute anything else and just put all this reputation chips on that one isolated ticket.
There is no trust needed when asking someone to fix a bug. It’s not like the maintainer would lose anything if the contributor failed to fix the bug.
Besides, I think it is natural to want recognition when you do a lot of work for free. Many other people wouldn’t do this unpaid work at all; recognizing their contribution is the bare minimum of good manners. Even in a company where employees are paid for their work, it is customary to give credit to co-workers who have helped you. Most people don’t like to work in places where they don’t feel appreciated, and that is also true in Open-Source.