Recruitment (Reviewers, Testers, Maintainers, Hobbyists)
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)
e.g. I think in the TPM subsystem we finally reached a good status, coming from having no active maintainer to a having at least a part-time maintainer with a two steady and excellent reviewers which also test manually most of the stuff!
From the 4.1 kernel report by jon corbet:
"over 60% of the changes going into this kernel passed through the hands of developers working for just five companies. This concentration reflects a simple fact: while many companies are willing to support developers working on specific tasks, the number of companies supporting subsystem maintainers is far smaller. Subsystem maintainership is also, increasingly, not a job for volunteer developers.."
-> How do we get companies to actively sponsor subsystem maintainership - if only at driver or subsubsystem level.
e.g.: I unfortunately failed at that with my company :/
-> Or how can we raise more funds to sponsor subsystem maintainer ship e.g. via Linux Foundation.
(so that the maintainer atleast can buy some test-hardware)
Also I would be interested in:
- What are the effects of the Eudyptula Challenge? how many people are still actively contributing (more than whitespace changes)
- What are the effects of the OutReachforWomen Program? how many people are still actively contributing (more than whitespace changes)
Nominations:
Jason Cooper (auto-nominated), last years 'speaker'
Greg KH please... ;-)
Little Penguin Eudyptula
Sarah Sharp OPW
Peter Huewe Caught between hobbyist maintainer and sponsored dev.
Wants to attend a KS :)
Hi Peter,
Quoted 7 lines · On Wednesday 08 July 2015 01:21:40 Peter Huewe wrote:
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
I was about to propose a related core topic.
The reviewing and maintainership process seems to have a hard time scaling to the amount of contributions we receive, to the point where even well known and respected kernel developers get discourages.
Quoting http://www.spinics.net/lists/cpufreq/msg10609.html,
--------------------------------
Quoted 3 lines
I'm trying to convince management that one of the advantages of mainlining the port is that it is easier to switch to newer kernels. Do you agree with this assertion?
Yes and no. If you can get stuff upstream, it should make things easier.
The difficult bit - and time consuming bit - is getting code upstream. Even in my position, I'd suggest allowing about five years for that activity, and even then don't have expectations of getting everything upstream.
Frankly now, my advice to people would be to just not bother, it's *way* too much effort to get everything to an acceptable state, especially if the SoC has no support what so ever.
--------------------------------
That's a very serious red warning in my opinion.
Throwing more maintainers, co-maintainers or sub-maintainers at the kernel won't magically solve this, as the more core developers a subsystem has the more difficult it will be for them to synchronize. I would like share experience about good practice rules that have proved to be effective.
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
We can't keep people interested if even maintainers get discouraged. Solving (or at least relieving) that problem won't be enough to keep people interested, but it's a prerequisite in my opinion.
Quoted 47 lines
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)e.g. I think in the TPM subsystem we finally reached a good status, coming from having no active maintainer to a having at least a part-time maintainer with a two steady and excellent reviewers which also test manually most of the stuff!
From the 4.1 kernel report by jon corbet:
"over 60% of the changes going into this kernel passed through the hands of developers working for just five companies. This concentration reflects a simple fact: while many companies are willing to support developers working on specific tasks, the number of companies supporting subsystem maintainers is far smaller. Subsystem maintainership is also, increasingly, not a job for volunteer developers.."-> How do we get companies to actively sponsor subsystem maintainership - if only at driver or subsubsystem level.
e.g.: I unfortunately failed at that with my company :/-> Or how can we raise more funds to sponsor subsystem maintainer ship e.g. via Linux Foundation.
(so that the maintainer atleast can buy some test-hardware)Also I would be interested in:
- What are the effects of the Eudyptula Challenge? how many people are still actively contributing (more than whitespace changes)
- What are the effects of the OutReachforWomen Program? how many people are still actively contributing (more than whitespace changes)Nominations:
Jason Cooper (auto-nominated), last years 'speaker'
Greg KH please... ;-)
Little Penguin Eudyptula
Sarah Sharp OPW
Peter Huewe Caught between hobbyist maintainer and sponsored dev.
Wants to attend a KS :)
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 10 lines · Peter Huewe
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
Quoted 6 lines
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)
I like this proposal, thanks for making it. I'd be glad to help talk about this issue as I spend a lot of time working on dragging companies and developers into our community. We have a real lack of ways that people who are "reasonably skilled yet don't know what to work on" can do more to help contribute to the kernel.
Quoted 3 lines
-> Or how can we raise more funds to sponsor subsystem maintainer ship e.g. via Linux Foundation.
(so that the maintainer atleast can buy some test-hardware)
Buying test hardware is always a good thing, if people have a hard time with this, let me know, I've been able to get hardware for people in the past.
Quoted 3 lines
Nominations:
Jason Cooper (auto-nominated), last years 'speaker'
Greg KH please... ;-)
Again, I'd be glad to help talk about this, thanks.
greg k-h
Quoted 47 lines · Laurent Pinchart
Hi Peter,
Quoted 7 lines · On Wednesday 08 July 2015 01:21:40 Peter Huewe wrote:
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
I was about to propose a related core topic.
The reviewing and maintainership process seems to have a hard time scaling to the amount of contributions we receive, to the point where even well known and respected kernel developers get discourages.
Quoting http://www.spinics.net/lists/cpufreq/msg10609.html,
--------------------------------
Quoted 3 lines
I'm trying to convince management that one of the advantages of mainlining the port is that it is easier to switch to newer kernels. Do you agree with this assertion?
Yes and no. If you can get stuff upstream, it should make things easier.
The difficult bit - and time consuming bit - is getting code upstream. Even in my position, I'd suggest allowing about five years for that activity, and even then don't have expectations of getting everything upstream.
Frankly now, my advice to people would be to just not bother, it's *way* too much effort to get everything to an acceptable state, especially if the SoC has no support what so ever.
--------------------------------That's a very serious red warning in my opinion.
Throwing more maintainers, co-maintainers or sub-maintainers at the kernel won't magically solve this, as the more core developers a subsystem has the more difficult it will be for them to synchronize. I would like share experience about good practice rules that have proved to be effective.
Quoted 3 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
Quoted 8 lines
Quoted 3 lines
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.We can't keep people interested if even maintainers get discouraged. Solving (or at least relieving) that problem won't be enough to keep people interested, but it's a prerequisite in my opinion.
Problem is multi-dimensional.
Every maintainer has a different style and different preferences. Even after being a maintainer for multiple years, I find it all but impossible to get it right for every maintainer if I submit a patch for some random subsystem. There may be minor coding style differences, subject line differences, or something else that is really cosmetic. Just finding the preferences for a specific subsystem can be challenging and time consuming.
For my part, if I get such a patch, I try to remain friendly and either fix up whatever I dislike myself (if I have the time and it is truly cosmetic), or I ask for a respin. Some maintainers less than friendly in such situations, assume that everyone who doesn't know the perfect style for a given subsystem are clueless, and respond accordingly.
Not really encouraging.
It happened several times to me that a maintainer rejected one of my patches for less than obvious reasons. Sure, I could spend the time and try to convince the maintainer to accept it. Unfortunately, I don't always have the time to do that. In once recent case, where I did spend the time, and I thought the maintainer had agreed to accept the patch, I ended up getting an automated patchwork email telling me that the patch was deferred indefinitely. Not really encouraging either.
Essentially it takes a lot of time by submitters to gain the trust of maintainers - and that may even be the case if the submitter is also a maintainer. Not everyone has that much time (and/or patience).
Is there anything we can do about that ? I honestly don't know. I know I can be quite stubborn myself, after all, so I can't really complain and try to take away the right of others to be just as stubborn as I might be. After all, I don't want to be forced to accept a patch from some other maintainer either if I think it is wrong. But am open to suggestions.
Guenter
Quoted 10 lines · Peter Huewe
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
Quoted 6 lines
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)
Good topic.
Unfortunately, there are not too many incentives for people to become code reviewers or testers, or at least to spend more time reviewing patches.
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
Thanks,
Rafael
Quoted 23 lines · Rafael J. Wysocki
Quoted 10 lines · Peter Huewe
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.Quoted 6 lines
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)Good topic.
Unfortunately, there are not too many incentives for people to become code reviewers or testers, or at least to spend more time reviewing patches.
Quoted 7 lines
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
You could make a Reviewed-by tag required before a patch can be included in a submaintainer's tree. At least some maintainers seem to (arbitrarily?) require this at times. However, if you do that then it would likely slow down development quite a bit. Then Greg might cry because he wouldn't get to show pretty graphs at conferences about how fast the rate of change is in the kernel.
(I would love to see a graph comparing rate of change to rate of regressions/bugs, but then people would have to know the latter.)
josh
Quoted 52 lines · On Tue, 07 Jul 2015 17:50:39 -0700 Guenter Roeck <[email protected]> wrote:
Quoted 51 lines · Laurent Pinchart
Hi Peter,
Quoted 7 lines · On Wednesday 08 July 2015 01:21:40 Peter Huewe wrote:
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
I was about to propose a related core topic.
The reviewing and maintainership process seems to have a hard time scaling to the amount of contributions we receive, to the point where even well known and respected kernel developers get discourages.
Quoting http://www.spinics.net/lists/cpufreq/msg10609.html,
--------------------------------
Quoted 3 lines
I'm trying to convince management that one of the advantages of mainlining the port is that it is easier to switch to newer kernels. Do you agree with this assertion?
Yes and no. If you can get stuff upstream, it should make things easier.
The difficult bit - and time consuming bit - is getting code upstream. Even in my position, I'd suggest allowing about five years for that activity, and even then don't have expectations of getting everything upstream.
Frankly now, my advice to people would be to just not bother, it's *way* too much effort to get everything to an acceptable state, especially if the SoC has no support what so ever.
--------------------------------That's a very serious red warning in my opinion.
Throwing more maintainers, co-maintainers or sub-maintainers at the kernel won't magically solve this, as the more core developers a subsystem has the more difficult it will be for them to synchronize. I would like share experience about good practice rules that have proved to be effective.
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
Quoted 5 lines
Quoted 4 lines
We can't keep people interested if even maintainers get discouraged. Solving (or at least relieving) that problem won't be enough to keep people interested, but it's a prerequisite in my opinion.
Problem is multi-dimensional.
Indeed! I wonder if we can list the dimensions.
Variability: as you say, different people want different things, and
care to different degrees about them. 'checkpatch' and 'CodingStyle' help with some of that (though different people care differently about checkpatch). Maybe the MAINTAINERS file could list the preferred Subject: line and checkpatch flags for each maintainer. Then we just need to herd all those wild-cats towards updating their maintainers entry.
I feel there is a related issue that might be called "Policy", though maybe it is a separate issue. There are a lot of areas where the "right" thing to do from a design perspective isn't really clear. "devicetree" "driver model" "sysfs attributes" "system call or virtual filesystem" "socket or char-device" all come to mind as being areas where different intelligent people differ. To a large extent they don't really matter as long as there is consistency. In areas where Linus cares, he can force consistency (if he notices). But I think there are a lot of areas where he doesn't care and so it is very hard to find something that is "right". If the maintainer can say "this is wrong, do it this way" then that is useful. But when all they can say is "uhm. this doesn't seem right but I'm not really sure" it is hard to make progress. I've had a couple of those recently, and could imagine myself saying that in some circumstances. So: a technical committee to resolves unclear questions of design. They are right, be definition, even when they are wrong.
Busy-ness: maintainers are busy people. Some tools can help with that,
some tools can hinder it. There is no way to find if your maintainer is annoyed at you or just busy (I respond much the same way in both conditions). A social network tools that tells everyone "Neil's current state is: grumpy".
Competence: I don't mean "in-" here. But maintainers tend to get to
be maintainers because they were good at something else, and not good enough at hiding from the "maintainer" role. There is a paradox here as a maintainer must be good at saying "No", but if they were they might never have agreed to become a maintainer. Is the kernel community big enough that we need "professional maintainers" (other than GregKH and akpm)? People who can sift the wheat for that chaff, know enough about most subsystems that they can make sensible comments and recommendations, and have the patience to shepherd things along.
People who have the authority to bypass the technical maintainer if said maintainer isn't being responsive.
Other dimensions?
NeilBrown
Quoted 41 lines
Every maintainer has a different style and different preferences. Even after being a maintainer for multiple years, I find it all but impossible to get it right for every maintainer if I submit a patch for some random subsystem. There may be minor coding style differences, subject line differences, or something else that is really cosmetic. Just finding the preferences for a specific subsystem can be challenging and time consuming.
For my part, if I get such a patch, I try to remain friendly and either fix up whatever I dislike myself (if I have the time and it is truly cosmetic), or I ask for a respin. Some maintainers less than friendly in such situations, assume that everyone who doesn't know the perfect style for a given subsystem are clueless, and respond accordingly.
Not really encouraging.It happened several times to me that a maintainer rejected one of my patches for less than obvious reasons. Sure, I could spend the time and try to convince the maintainer to accept it. Unfortunately, I don't always have the time to do that. In once recent case, where I did spend the time, and I thought the maintainer had agreed to accept the patch, I ended up getting an automated patchwork email telling me that the patch was deferred indefinitely. Not really encouraging either.
Essentially it takes a lot of time by submitters to gain the trust of maintainers - and that may even be the case if the submitter is also a maintainer. Not everyone has that much time (and/or patience).
Is there anything we can do about that ? I honestly don't know. I know I can be quite stubborn myself, after all, so I can't really complain and try to take away the right of others to be just as stubborn as I might be. After all, I don't want to be forced to accept a patch from some other maintainer either if I think it is wrong. But am open to suggestions.
Guenter
_______________________________________________
Ksummit-discuss mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/ksummit-discuss
Quoted 28 lines · On Tue, 7 Jul 2015 21:14:00 -0400 Josh Boyer <[email protected]> wrote:
Quoted 27 lines · Rafael J. Wysocki
Quoted 10 lines · Peter Huewe
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.Quoted 6 lines
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)Good topic.
Unfortunately, there are not too many incentives for people to become code reviewers or testers, or at least to spend more time reviewing patches.
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
Quoted 6 lines
Quoted 3 lines
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
You could make a Reviewed-by tag required before a patch can be included in a submaintainer's tree.
Nah, you need carrots, not sticks. And that really comes down to time and/or money. As the original post quoted:
Quoted 2 lines
Subsystem maintainership is also, increasingly, not a job for volunteer developers.."
In academia, there is a "sabbatical" system (or there was - at some Unis) where an academic could take 6 months or a year off to go and do something else: visit another institution - do some new research or new sort of teaching. Would you like a 6-month secondment to the Linux Foundation to be spent reviewing patches? I think I would... It would undoubtedly be a challenge to organise and to fund. But this issue has been ongoing and unanswered for so long that it seems likely that a radical change is required.
NeilBrown
Quoted 14 lines
At least some maintainers seem to
(arbitrarily?) require this at times. However, if you do that then it would likely slow down development quite a bit. Then Greg might cry because he wouldn't get to show pretty graphs at conferences about how fast the rate of change is in the kernel.(I would love to see a graph comparing rate of change to rate of regressions/bugs, but then people would have to know the latter.)
josh
_______________________________________________
Ksummit-discuss mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/ksummit-discuss
2015-07-08 10:14 GMT+09:00 Josh Boyer <[email protected]>:
Quoted 32 lines · Rafael J. Wysocki
Quoted 23 lines · Peter Huewe
Quoted 10 lines
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.Quoted 6 lines
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)Good topic.
Unfortunately, there are not too many incentives for people to become code reviewers or testers, or at least to spend more time reviewing patches.
Quoted 7 lines
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
Quoted 6 lines
You could make a Reviewed-by tag required before a patch can be included in a submaintainer's tree. At least some maintainers seem to (arbitrarily?) require this at times. However, if you do that then it would likely slow down development quite a bit. Then Greg might cry because he wouldn't get to show pretty graphs at conferences about how fast the rate of change is in the kernel.
Enforcing reviewed-by or tested-by tags won't be enough if no one actually will do the review and testing. The patch can wait indefinitely with maintainer's response "I expect an independent review". This goes back to first question - will such enforcement boost number of reviews or tests?
Before doing some work there is always a cause, an answer to "why I am doing this"? Employer may pay for my commits but would he pay for reviewing time? That is his decision and it would be difficult to change policies inside companies.
Other reason for doing open source work may be the fame. Being recognizable, getting better job offers, doing tasks which are sensible and meaningful for someone. Currently probably most of the fame goes to authors and maintainers. For example in the form of git log --author/committer= or LWN articles about statistics.
How to get more reviews from such people (when employer does not pay for it)? Give them fame! :)
Best regards,
Krzysztof
Quoted 4 lines · Josh Boyer
You could make a Reviewed-by tag required before a patch can be included in a submaintainer's tree. At least some maintainers seem to (arbitrarily?) require this at times. However, if you do that then it would likely slow down development quite a bit.
It doesn't seem to have slowed down the rate of change for the subsystems that currently require this, so why do you think it would?
Quoted 2 lines
Then Greg might cry because he wouldn't get to show pretty graphs at conferences about how fast the rate of change is in the kernel.
I don't have any graphs showing rate of change. I have a few "raw" numbers that I talk about, but that's just to scare people. Even if we went back to 2.5 development speeds (2.5 changes per hour), that's enough to scare people for my needs :)
Quoted 2 lines
(I would love to see a graph comparing rate of change to rate of regressions/bugs, but then people would have to know the latter.)
Want to start tracking that? We've needed someone to do that work for quite some time now, the fact that we've gotten by without it either means that no one sees the value in funding such a position and/or it's not really something that anyone cares about...
thanks,
greg k-h
Quoted 5 lines · NeilBrown
In academia, there is a "sabbatical" system (or there was - at some Unis) where an academic could take 6 months or a year off to go and do something else: visit another institution - do some new research or new sort of teaching. Would you like a 6-month secondment to the Linux Foundation to be spent reviewing patches? I think I would...
There's also consulting. Given enough cash, you could probably hire subsystem specialists to pay close attention at patches that are trying to be pushed by some individual or company. Objectively, of course.
Am Mittwoch, 8. Juli 2015, 04:03:04 schrieb Krzysztof Kozłowski:
Quoted 6 lines
Before doing some work there is always a cause, an answer to "why I am doing this"? Employer may pay for my commits but would he pay for reviewing time? That is his decision and it would be difficult to change policies inside companies.
Quoted 8 lines
Other reason for doing open source work may be the fame. Being recognizable, getting better job offers, doing tasks which are sensible and meaningful for someone. Currently probably most of the fame goes to authors and maintainers. For example in the form of
git log --author/committer=or LWN articles about statistics.How to get more reviews from such people (when employer does not pay for it)? Give them fame! :)
Exactly!
This is also what Rafael wrote in the other mail:
Quoted 3 lines
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
So changing our fame-statistics from commits to reviews and tested by might change the situation a bit.
-> The next LWN stats and coverage should probably focus on the reviewed-by / tested-by stats.
People love to be on some "top 10" lists - and also they can show something like that to their bosses.
"I've been a kernel reviewer and tester" -- meh, who cares
"I've been a top 100 kernel reviewer and tester over the last X releases" -- give him a raise/the job (esp. if kernel is not the core competency of the company :)
Another thing I noticed over the last few years (also in corporate), people get really motivated by memorabilia - "tokens of appreciation". E.g. I constantly wear my Google T-Shirt which I received for a contribution with such proud and so often that it is almost faded --- but still everytime I look at it I have a good feeling.
--> Maybe LF can organize something?
"Here is a small token of appreciation (t-shirt, cup) for spending countless hours on reviewing and testing stuff in the Linux kernel -- keep up the good work"
Quoted 3 lines
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
Yes again!
What I definitely would also recommend is to organize some 'get togethers', like a miniconf/minisummit at the next conference near you -- and where you grab a beer _together_ with the reviewers / testers afterwards (and maybe the maintainer can pay).
This also helps as forms of appreciation.
Thanks,
Peter
Am Mittwoch, 8. Juli 2015, 03:49:13 schrieb NeilBrown:
Quoted 11 lines
Nah, you need carrots, not sticks. And that really comes down to time
and/or money. As the original post quoted:
Quoted 2 lines
Subsystem maintainership is also, increasingly, not a job for volunteer developers.."
In academia, there is a "sabbatical" system (or there was - at some Unis) where an academic could take 6 months or a year off to go and do something else: visit another institution - do some new research or new sort of teaching. Would you like a 6-month secondment to the Linux Foundation to be spent reviewing patches? I think I would...
+1
Maybe this would also address overcoming the problem mentioned in the other emails that different subsystems have different expectations etc.
If I would have enough time to get to know other subsystems well (so that I can make the transistion "one-off"->"steady contributor"-
Quoted 1 line
"reviewer" -> "co-maintainer") this would defnitely reduce the friction
between the different subsystems and also smothen out the differences.
Peter
Quoted 18 lines · Rafael J. Wysocki
Quoted 10 lines · Peter Huewe
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.Quoted 6 lines
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)
Quoted 4 lines
Good topic.
Unfortunately, there are not too many incentives for people to become code reviewers or testers, or at least to spend more time reviewing patches.
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 7 lines
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
What other incentives or recognition mechanisms would you propose?
James
Quoted 8 lines · Greg KH
Quoted 4 lines · Josh Boyer
You could make a Reviewed-by tag required before a patch can be included in a submaintainer's tree. At least some maintainers seem to (arbitrarily?) require this at times. However, if you do that then it would likely slow down development quite a bit.
It doesn't seem to have slowed down the rate of change for the subsystems that currently require this, so why do you think it would?
That's SCSI and who else?
I think it improved SCSI a lot and got more people involved. Before there were some companies that didn't reply at all when you emailed them fixes for their driver. They just left everything for James. Adding the rule that every patch needed two reviews probably sped things up.
regards,
dan carpenter
Quoted 18 lines · Peter Hüwe
Am Mittwoch, 8. Juli 2015, 04:03:04 schrieb Krzysztof Kozłowski:
Quoted 6 lines
Before doing some work there is always a cause, an answer to "why I am doing this"? Employer may pay for my commits but would he pay for reviewing time? That is his decision and it would be difficult to change policies inside companies.
Quoted 8 lines
Other reason for doing open source work may be the fame. Being recognizable, getting better job offers, doing tasks which are sensible and meaningful for someone. Currently probably most of the fame goes to authors and maintainers. For example in the form of
git log --author/committer=or LWN articles about statistics.How to get more reviews from such people (when employer does not pay for it)? Give them fame! :)
Exactly! This is also what Rafael wrote in the other mail:
Quoted 8 lines
Quoted 3 lines
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
So changing our fame-statistics from commits to reviews and tested by might change the situation a bit. -> The next LWN stats and coverage should probably focus on the reviewed-by /
tested-by stats. People love to be on some "top 10" lists - and also they can show something like that to their bosses.
I think we also need to encourage multiple sign offs from one person
on drivers sometimes. Often you'll get a 'I tested this and also
reviewed it' but as I'm the author / maintainer of the original driver I'll Ack it. Perhaps these cases should have all 3 tags in the commit.
Quoted 3 lines
"I've been a kernel reviewer and tester" -- meh, who cares
"I've been a top 100 kernel reviewer and tester over the last X releases" -- give him a raise/the job (esp. if kernel is not the core competency of the company :)
I'm very luck in IIO in that I have a core set of very good reviewers with (I think) a mix of paid and volunteers. As a volunteer Maintainer I couldn't cope with the rate of patches without them!
One thing that happens fairly often is that I get a very good initial review in then the reviewer moves on to other patches. I suspect this is because they are focusing on where they can do the most productive work. Sometimes I go to the effort of chasing them up for an ack / reviewed by, but often they get no recognition at all.
Note I tend to do an additional review (often v3 or later by the time I get to them) but these guys have done a lot of the leg work. One of my reviewers specializes in very detailed reviews slightly after I have applied the patches, but that's another story :)
So how to give these incredibly helpful people more recognition? Do other maintainers add reviewed-by tags sometimes without the reviewer specifically giving them? The docs have always said these should indicate that the reviewer is happy with the result. In this case the reviewer may not have looked at the result, but contributed earlier in the process.
Does anyone else actually get these sorts of reviews?
Quoted 14 lines
Another thing I noticed over the last few years (also in corporate), people get really motivated by memorabilia - "tokens of appreciation".
E.g. I constantly wear my Google T-Shirt which I received for a contribution with such proud and so often that it is almost faded --- but still everytime I look at it I have a good feeling.--> Maybe LF can organize something?
"Here is a small token of appreciation (t-shirt, cup) for spending countless hours on reviewing and testing stuff in the Linux kernel -- keep up the good work"
Quoted 7 lines
Quoted 3 lines
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
Yes again!
What I definitely would also recommend is to organize some 'get togethers',
like a miniconf/minisummit at the next conference near you -- and where you grab a beer _together_ with the reviewers / testers afterwards (and maybe the maintainer can pay). This also helps as forms of appreciation.
I'm particularly bad at this. Have only ever actually met one of my regular reviewers (out of 6+). Note that for some subsystems the conference attendance is actually pretty limited / random and chances of a actually encountering many of the reviewers is lowish.
Guys who put in a few hours a week are the bread and butter or reviewing for my area, but that may well be all the time they have as much as they'd like to travel to conferences!
Jonathan
Quoted 19 lines · James Bottomley
Quoted 18 lines · Rafael J. Wysocki
Quoted 8 lines · Peter Huewe
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers. For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
Quoted 6 lines
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)Good topic.
Quoted 8 lines
Quoted 2 lines
Unfortunately, there are not too many incentives for people to become code reviewers or testers, or at least to spend more time reviewing patches.
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Sounds like a good idea to me, though it would only effect a tiny
percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
Quoted 10 lines
Quoted 8 lines
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
What other incentives or recognition mechanisms would you propose?
Again, it's not much an an incentive (and has disadvantages) but explicitly acknowledging reviewers for more areas in MAINTAINERS might give them more of a warm fuzzy feeling! (keeping these entries up to date is also important - another nightmare for Maintainers as they don't want anyone to feel not acknowledged as they weren't included in the 'official' reviewers list).
They do then get personally emailed lots and lots of patches as a result but they clearly like that sort of thing :)
So to me it seems like it's the small stuff that just gives a warm fuzzy feeling that may make all the difference.
Jonathan
Quoted 8 lines
James
_______________________________________________
Ksummit-discuss mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/ksummit-discuss
Quoted 10 lines · Josh Boyer
Quoted 3 lines
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
You could make a Reviewed-by tag required before a patch can be included in a submaintainer's tree. At least some maintainers seem to (arbitrarily?) require this at times. However, if you do that then it would likely slow down development quite a bit. Then Greg might cry because he wouldn't get to show pretty graphs at conferences about how fast the rate of change is in the kernel.
It's far too common to send out a patch series, receive lots of valuable comments and suggestions, adapt according to feedback, and send out again (repeat a few cycles). Suddenly the patches looks perfect, no more comments, but also no Acked-by or Reviewed-By. Just silence.
Requiring a Reviewed-by tag is not a solution, unless there's a real incentive for people to add such tags. Finding such an incentive can be difficult, and may turn out to make matters worse (cfr. patent officers paid per patent granted).
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Hey,
Quoted 15 lines
I'm very luck in IIO in that I have a core set of very good reviewers with (I think) a mix of paid and volunteers. As a volunteer Maintainer I couldn't cope with the rate of patches without them!
One thing that happens fairly often is that I get a very good initial review in then the reviewer moves on to other patches. I suspect this is because they are focusing on where they can do the most productive work. Sometimes I go to the effort of chasing them up for an ack / reviewed by, but often they get no recognition at all.
Note I tend to do an additional review (often v3 or later by the time I get to them) but these guys have done a lot of the leg work. One of my reviewers specializes in very detailed reviews slightly after I have applied the patches, but that's another story :)
Quoted 7 lines
So how to give these incredibly helpful people more recognition? Do other maintainers add reviewed-by tags sometimes without the reviewer
specifically giving them? The docs have always said these should indicate that the reviewer is happy with the result. In this case the reviewer may not have looked at the result, but contributed earlier in the process.
Actually I do, at least if I have the feeling that it would be in the reviewers intention. Credit where credit is due.
If I'm unsure I mail the reviewers and ask them (or via IRC)
Quoted 1 line
Does anyone else actually get these sorts of reviews?
Yes happens a lot - v1-5 get a lot of reviews , v8 gets none except my own :)
But the important stuff is usually dealt with in v1-3. so I usually add the reviewed-by tags if nothing fundamentally has changed So the Situation is much likr in iio
(Yes in TPM we usually need v5 or more:)
Peter
Signature · 1 line
Sent from my mobile
I totally agree with Jonathan.
The warm fuzzy feeling makes the difference.
Beginning with thank you emails and seasonal greetings, but also being listed in MAINTAINERS creates a feeling of belonging. So this is something we already have improved... But still a long way to go!
I also think that an invite to something like KS is usually seen as a reward, since it is an invite only event with the big penguins.
Peter
Signature · 1 line
Sent from my mobile
Quoted 9 lines · Greg KH
Quoted 4 lines · Josh Boyer
You could make a Reviewed-by tag required before a patch can be included in a submaintainer's tree. At least some maintainers seem to (arbitrarily?) require this at times. However, if you do that then it would likely slow down development quite a bit.
It doesn't seem to have slowed down the rate of change for the subsystems that currently require this, so why do you think it would?
I think there's probably a cause and effect thing going on there - it's more likely that a subsystem will start to impose such requirements if they are confident that it is practical to get reviews of sufficient quality in. I'd guess at least some of the time it's a formalisation of existing practice rather than a completely new requirement.
Quoted 7 lines
Quoted 2 lines
(I would love to see a graph comparing rate of change to rate of regressions/bugs, but then people would have to know the latter.)
Want to start tracking that? We've needed someone to do that work for quite some time now, the fact that we've gotten by without it either means that no one sees the value in funding such a position and/or it's not really something that anyone cares about...
Well, first we'd need to find a way of counting the bugs and regressions.
Quoted 8 lines · Greg KH
Quoted 4 lines · Josh Boyer
You could make a Reviewed-by tag required before a patch can be included in a submaintainer's tree. At least some maintainers seem to (arbitrarily?) require this at times. However, if you do that then it would likely slow down development quite a bit.
It doesn't seem to have slowed down the rate of change for the subsystems that currently require this, so why do you think it would?
Probably because such subsystems have always required it? If it were a new imposition on a subsystem, I suspect it would certainly impact things, at least at first.
Quoted 7 lines
Quoted 2 lines
Then Greg might cry because he wouldn't get to show pretty graphs at conferences about how fast the rate of change is in the kernel.
I don't have any graphs showing rate of change. I have a few "raw" numbers that I talk about, but that's just to scare people. Even if we went back to 2.5 development speeds (2.5 changes per hour), that's enough to scare people for my needs :)
Heh.
Quoted 7 lines
Quoted 2 lines
(I would love to see a graph comparing rate of change to rate of regressions/bugs, but then people would have to know the latter.)
Want to start tracking that? We've needed someone to do that work for quite some time now, the fact that we've gotten by without it either means that no one sees the value in funding such a position and/or it's not really something that anyone cares about...
I think you're wrong on both counts there, sorry.
In order to track this well, you need data from users. And therein lies one of the problems. The majority of users don't use kernel.org kernels. They use distro kernels. The distros have data and tools to help track bugs and regressions, but upstream is somewhat loathe to look at anything that starts with b and ends with zilla. Why? Because the data coming from users is often utterly junk. You get a kernel splat and a "I don't know why this happened." And frankly, I don't expect them to know why it happened either. Particularly when you have subsystems that are using WARN_ON as a fixme comment and sprinkling them all over the damn place.
So you have users that don't/are afraid to talk to upstream, distro maintainers trying to play middle men and being overwhelmed, and upstream who is very responsive when contacted directly but because they use self-built kernels the request is usually "bisect". End users can't bisect without hand-holding, so the distro maintainers are left doing that too. The learning curve for creating a good bug report is pretty steep, and the ability to help debug it is even steeper.
Now that isn't to say that data doesn't exist. As I alluded to, the various bugzillas are full of regressions and bugs. But there is no aggregation of that data across instances, and everything is terrible. I literally spent a year doing very little other than bug triage and random fixing. Fedora's bug count for the kernel went from over 1000 bugs to just under 500. That sounds great, but it really isn't. The net result wasn't 500 bugfixes. I don't have 500 commits in the kernel, nor 500 Reviewed-by or Tested-by or Reported-by tags. It was literally cleanup of bugzilla, not kernel issues. (To be sure, some issues were fixes for the users, but those were rare.) And this was with Fedora, which sticks very very closely to the latest upstream release.
Ignoring the bug reporting pipeline problem for a minute, there is other data as well. The new Fixes: tag could easily be scripted to count as a bug/regression. Except it is fairly new, and isn't as widely used as one would like yet. That is pretty trivial to count though and I don't think it would paint an accurate picture at all.
I intended this to be short, but it wasn't. Hopefully it didn't come off as a big rant. I simply think the problem is a lot more complicated that "no one sees value or no one cares." It is really signal to noise, a huge backlog, and figuring out how to get the end users working with the developers without needed a distro translator. Or getting the developers working the other way, but when has that ever happened in the software industry?
josh
Quoted 4 lines · On Wed, 8 Jul 2015 09:04:58 +0200 Peter Hüwe <[email protected]> wrote:
So changing our fame-statistics from commits to reviews and tested by might change the situation a bit.
-> The next LWN stats and coverage should probably focus on the reviewed-by / tested-by stats.
I do occasionally report those numbers with the rest. The reason it doesn't happen very often is simple: it's a small minority of patches that carry such tags. As such, I don't think the numbers actually reflect the reviewing and testing going on; they just reflect the placement of the tags. Among other things, that makes the system relatively easy to game, and, in the past, I've seen that happening.
Should anybody be curious, I'll append the latest, hot-off-the-repo numbers for 4.2.
jon
[12,099 non-merge changesets total when I ran this]
Developers with the most reviews (total 2597)
Ian Abbott 149 (5.7%) Borislav Petkov 148 (5.7%) Hannes Reinecke 100 (3.9%) Christoph Hellwig 73 (2.8%) H Hartley Sweeten 62 (2.4%) Christian König 57 (2.2%) Tomas Henzl 54 (2.1%) Alex Deucher 51 (2.0%) David Gibson 49 (1.9%) Scott Teel 42 (1.6%)
Developers with the most test credits (total 775)
Joerg Roedel 35 (4.5%) Keita Kobayashi 35 (4.5%) Krishneil Singh 31 (4.0%) Arnaldo Carvalho de Melo 30 (3.9%) Ira Weiny 23 (3.0%) Doug Ledford 23 (3.0%) Aaron Brown 21 (2.7%) Alex Ng 21 (2.7%) Javier Martinez Canillas 19 (2.5%)
Developers who gave the most tested-by credits (total 775)
Michael Wang 46 (5.9%) Joerg Roedel 42 (5.4%) Kuninori Morimoto 36 (4.6%) Jiang Liu 35 (4.5%) Mel Gorman 31 (4.0%) Vitaly Kuznetsov 21 (2.7%) Andre Przywara 20 (2.6%) Marek Szyprowski 19 (2.5%) Lv Zheng 17 (2.2%) Don Skidmore 17 (2.2%)
Developers with the most report credits (total 467)
Fengguang Wu 65 (13.9%) Dan Carpenter 26 (5.6%) Russell King 21 (4.5%) Ingo Molnar 10 (2.1%) Stephen Rothwell 9 (1.9%) Christoph Hellwig 5 (1.1%) Kevin Hilman 5 (1.1%) Sergey Senozhatsky 5 (1.1%) Jim Davis 5 (1.1%) Arnaldo Carvalho de Melo 4 (0.9%)
Developers who gave the most report credits (total 467)
Thomas Gleixner 30 (6.4%) Paul E. McKenney 14 (3.0%) Lv Zheng 12 (2.6%) Eric Dumazet 8 (1.7%) Paul Gortmaker 8 (1.7%) Peter Zijlstra 8 (1.7%) Takashi Iwai 7 (1.5%) Stephen Boyd 7 (1.5%) Aleksey Makarov 7 (1.5%) Filipe Manana 6 (1.3%)
Quoted 4 lines · Guenter Roeck
... In once recent case, where I did spend the time,
and I thought the maintainer had agreed to accept the patch, I ended up getting an automated patchwork email telling me that the patch was deferred indefinitely. Not really encouraging either.
Hmm, I use patchwork, but I don't have any idea what it looks like on the submitter's side. If it generates discouraging emails, that's bad news to me. I change the state of lots of patches because (a) they were cross-posted and I expect another maintainer to deal with them,
(b) they have been superseded, (c) there have been reviews that require a respin, etc. I'm not very careful about the actual state because from my point of view, all the states do the same thing:
remove the patch from my to-do list.
I wish I knew how to use patchwork better, or had a smarter workflow that could comprehend a series as a single entity. Patchwork is a lot of clicking, but I don't know anything better.
Bjorn
Quoted 4 lines · Peter Huewe
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
Agreed. I have a few fresh thoughts on this area. Not necessarily good ones, but at least fresh. :-P
Quoted 2 lines
We are definitely short on reviewers and thus have mostly overloaded maintainers.
Ack.
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.
Here we need to have the correct mindset. Kernel development is hard, detailed work. It's very rewarding, but simply put, most people aren't cut out to do it. I view the dropout rate as a *good* thing. It's a _selection_ process more than a education/training process.
With most of the hard jobs in life, take a look at the training/education program, and you'll see it: 80% drop out rate? That's selection. Kernel work is one of those 'hard jobs'.
This is important to realize because it changes how we view recruitment. We shouldn't be trying to keep everybody we recruit. Rather, we should be giving more people trial runs and see how they work out as they learn the process.
iow, if an 80% drop out rate gives us the caliber of dev we need for the long term health of the community, then it's a numbers game. Say we saw 40 new people last year, which turned into 8 regular contributors. Now we want to double that. We can lower the standard to get 16 out of 40, yuck. Or, we can outreach to 80 for trial runs, and get 16.
The discussion, I think, would revolve around: Am I smoking crack, or does everyone agree with this view? How can we create slots for newcomers to contribute real changes? Where do we reach out to for candidates? And, how do we quantify success or failure at some point in the future?
Quoted 3 lines
- encourage regular contributors to become reviewers and testers
- reviewers to become co-maintainers and finally maintainers (once the original maintainer is used up or moves up/on)
heh. 'used up' :-)
Quoted 7 lines
From the 4.1 kernel report by jon corbet:
"over 60% of the changes going into this kernel passed through the hands of developers working for just five companies. This concentration reflects a simple fact: while many companies are willing to support developers working on specific tasks, the number of companies supporting subsystem maintainers is far smaller. Subsystem maintainership is also, increasingly, not a job for volunteer developers.."
Well, I disagree. Not because I think Jon is wrong, but because we need to bring in new blood *somewhere*. co-maintainer/reviewer is one of many possibilities. If we don't have enough slots for newcomers (especially on a trial basis), that's our fault.
I think it's also worth noting how many of those kernel developers started out as hobbyist/volunteers. The truth is, once you've been around a few cycles as a hobbyist/volunteer, job offers come out of nowhere. So a statistic I'd love to see is the percentage of conversions.
Quoted 3 lines
-> How do we get companies to actively sponsor subsystem maintainership - if only at driver or subsubsystem level.
e.g.: I unfortunately failed at that with my company :/
meh, companies are fickle. I think it's enough for them to be paying a salary of a kernel dev/maintainer. It's a cost they can quantify the benefits of. If a company does a Crazy Ivan [1], then the kernel dev goes to work someplace else. iow, it's the human that matters and can be relied on, not the company.
Quoted 3 lines
Also I would be interested in:
- What are the effects of the Eudyptula Challenge? how many people are still actively contributing (more than whitespace changes)
If the Eudyptula folks have statistics, I'd love to see them.
Quoted 2 lines
Nominations:
Jason Cooper (auto-nominated), last years 'speaker'
I think it was the year before last, I couldn't make it last year. :-(
thx,
Jason.
[1] https://en.wikipedia.org/wiki/Crazy_Ivan (rapid, unexpected course changes)
Quoted 16 lines · Bjorn Helgaas
Quoted 4 lines · Guenter Roeck
... In once recent case, where I did spend the time,
and I thought the maintainer had agreed to accept the patch, I ended up getting an automated patchwork email telling me that the patch was deferred indefinitely. Not really encouraging either.Hmm, I use patchwork, but I don't have any idea what it looks like on the submitter's side. If it generates discouraging emails, that's bad news to me. I change the state of lots of patches because (a) they were cross-posted and I expect another maintainer to deal with them,
(b) they have been superseded, (c) there have been reviews that require a respin, etc. I'm not very careful about the actual state because from my point of view, all the states do the same thing:
remove the patch from my to-do list.
Quoted 4 lines
I wish I knew how to use patchwork better, or had a smarter workflow that could comprehend a series as a single entity. Patchwork is a lot of clicking, but I don't know anything better.
Wasn't you (in case you think so), and I don't think it is a problem that patchwork sends e-mail. The problem in this case was that the maintainer seemed to suggest that he would accept the patch before deferring it. At that point I gave up pushing for it.
Now, if you set a bug to "deferred" state because you intend to pick it up for the next release, that would be different and might in fact be considered discouraging, unless you let the submitter know what is going on.
Guenter
Quoted 24 lines · Peter Hüwe
Am Mittwoch, 8. Juli 2015, 04:03:04 schrieb Krzysztof Kozłowski:
Quoted 6 lines
Before doing some work there is always a cause, an answer to "why I am doing this"? Employer may pay for my commits but would he pay for reviewing time? That is his decision and it would be difficult to change policies inside companies.
Quoted 8 lines
Other reason for doing open source work may be the fame. Being recognizable, getting better job offers, doing tasks which are sensible and meaningful for someone. Currently probably most of the fame goes to authors and maintainers. For example in the form of
git log --author/committer=or LWN articles about statistics.How to get more reviews from such people (when employer does not pay for it)? Give them fame! :)
Exactly!
This is also what Rafael wrote in the other mail:Quoted 3 lines
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
Quoted 6 lines
So changing our fame-statistics from commits to reviews and tested by might change the situation a bit.
-> The next LWN stats and coverage should probably focus on the reviewed-by / tested-by stats.
People love to be on some "top 10" lists - and also they can show something like that to their bosses.
gack. see below.
Quoted 1 line
"I've been a kernel reviewer and tester" -- meh, who cares
Show me a concrete example where that has been expressed. I've had the exact opposite experience. Typically I've had to tone down the expectations of others.
Quoted 3 lines
"I've been a top 100 kernel reviewer and tester over the last X releases" -- give him a raise/the job (esp. if kernel is not the core competency of the company :)
Gah! Please don't add gamification into this. It attracts the wrong sorts of people. We already have a large swath of society that want a cookie and a pat on the head for doing the most mundane things.
Plus these systems built with good intentions always go awry. "Hey! You didn't add a tag for me because I spotted a typo!" <stomps and huffs> Or, "My boss / HR gave me less of a raise because my stats dropped this quarter, wtf?"
This is a path we do *not* want to walk down.
Quoted 4 lines
--> Maybe LF can organize something?
"Here is a small token of appreciation (t-shirt, cup) for spending countless hours on reviewing and testing stuff in the Linux kernel -- keep up the good work"
How about "Here's an invite to the KS, because we value your opinion and would like you to take part in the process." ;-)
Quoted 4 lines
Quoted 3 lines
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
Yes again!
Disagree. But I've said my piece above.
Quoted 4 lines
What I definitely would also recommend is to organize some 'get togethers', like a miniconf/minisummit at the next conference near you -- and where you grab a beer _together_ with the reviewers / testers afterwards (and maybe the maintainer can pay).
Enhancing the community effect is something I can get on board with. Buying a few rounds of drinks goes a long way. Getting the folks together in meat-space is the hard ($$) part.
thx,
Jason.
Quoted 21 lines · Guenter Roeck
Quoted 16 lines · Bjorn Helgaas
Quoted 4 lines · Guenter Roeck
... In once recent case, where I did spend the time,
and I thought the maintainer had agreed to accept the patch, I ended up getting an automated patchwork email telling me that the patch was deferred indefinitely. Not really encouraging either.Hmm, I use patchwork, but I don't have any idea what it looks like on the submitter's side. If it generates discouraging emails, that's bad news to me. I change the state of lots of patches because (a) they were cross-posted and I expect another maintainer to deal with them,
(b) they have been superseded, (c) there have been reviews that require a respin, etc. I'm not very careful about the actual state because from my point of view, all the states do the same thing:
remove the patch from my to-do list.Quoted 3 lines
I wish I knew how to use patchwork better, or had a smarter workflow that could comprehend a series as a single entity. Patchwork is a lot of clicking, but I don't know anything better.
Quoted 8 lines
Wasn't you (in case you think so), and I don't think it is a problem that patchwork sends e-mail. The problem in this case was that the maintainer seemed to suggest that he would accept the patch before deferring it. At that point I gave up pushing for it.
Now, if you set a bug to "deferred" state because you intend to pick it up for the next release, that would be different and might in fact be considered discouraging, unless you let the submitter know what is going on.
That's one thing I don't like about patchwork: there's no way that I know of to annotate the state change. I'd like a way to change the state to "Changes requested" along with a pointer to the relevant email. Or to "Not applicable" along with a pointer to the other tree I expect it to go through.
It'd be nice if one could include patchwork directives in an email, the way you can with the Debian bug tracker.
Bjorn
Quoted 5 lines · Peter Hüwe
Am Mittwoch, 8. Juli 2015, 04:03:04 schrieb Krzysztof Kozłowski:
Quoted 3 lines
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
Quoted 7 lines
Yes again!
What I definitely would also recommend is to organize some 'get togethers', like a miniconf/minisummit at the next conference near you -- and where you grab a beer _together_ with the reviewers / testers afterwards (and maybe the maintainer can pay).
This also helps as forms of appreciation.
I think that this was a major purpose served by Kernel Summit when it was founded. Over time KS grew along with the importance of the kernel until we started trying to cap KS attendance in the "about 100" range.
Various mini-summits, workshops, and such have been instituted over time. At least part of the goal of providing such outlets is to include a broader swath of the kernel community. I believe that was part (perhaps most) of the motivation for the KS format change to include workshops over the past several years as well. Do you think that we need even more such events? Or just bigger ones?
John
Signature · 2 lines
John W. Linville Someday the world will need a hero, and you [email protected] might be all we have. Be ready.
Quoted 8 lines · Jason Cooper
Quoted 1 line · Peter Hüwe
"I've been a kernel reviewer and tester" -- meh, who cares
Show me a concrete example where that has been expressed. I've had the exact opposite experience. Typically I've had to tone down the expectations of others.
Lucky you.
In my experience, code reviews often don't get much attention by project managers responsible for commercial projects. If anything, quite the opposite. The Linux kernel development culture is quite different.
Linux kernel:
"Thanks a lot for reviewing my code and making it better".
Commercial:
"Why do your reviews always take such a long time ? You are holding up the release!"
Granted, that doesn't happen everywhere, but I have seen it more than once, and I would content that this kind of culture is pretty widely spread.
Anyone entering such an environment might actually encounter negative reactions to "I am a kernel reviewer and tester". Of course, one might argue that joining an affected company might not be a good idea in the first place, but not everyone has that much flexibility or choice.
I am not saying that it would be a bad idea to give code reviewers more credit; quite the contrary. However, I think it would be wrong to assume or expect that giving reviewers more credit would improve their chances for employment. It would, however, result in reviewers feeling recognized for themselves, which is a good thing.
Why does it matter ? I had a discussion a while ago with the founder of one of the web sites providing product reviews. I suggested to give product reviewers some kind of monetary reward for their reviews, eg part of the advertising revenue created by the site. Feedback I got was that reviewers typically don't care about monetary rewards, but they do care about recognition and about their standing in the community.
Guenter
Quoted 10 lines · Laurent Pinchart
Quoted 2 lines · On Wednesday 08 July 2015 01:21:40 Peter Huewe wrote:
We are definitely short on reviewers and thus have mostly overloaded maintainers.
I was about to propose a related core topic.
The reviewing and maintainership process seems to have a hard time scaling to the amount of contributions we receive, to the point where even well known and respected kernel developers get discourages.
tl;dr - upstreaming support for out of tree SoCs is currently often hard and time consuming.
Quoted 4 lines
Throwing more maintainers, co-maintainers or sub-maintainers at the kernel won't magically solve this, as the more core developers a subsystem has the more difficult it will be for them to synchronize. I would like share experience about good practice rules that have proved to be effective.
Right. In the specific case of upstreaming out of tree SoCs it's often in a large part part that there's some massive technical debt in the out of tree code working around generic problems in mainline, things like missing features or subsystems. On the one hand those are the hardest bits to get solved upstream, but equally because they present generic issues they should be the easiest to collaborate on.
Tim Bird (CCed) has been working to try to get people together to try to analyze what's in the kernels people ship on product and see what we can do to bring that debt down, there's already some people starting to do some active work on this.
Quoted 3 lines · Peter Huewe
-> How do we get companies to actively sponsor subsystem maintainership - if only at driver or subsubsystem level.
e.g.: I unfortunately failed at that with my company :/
One thing I found worked really well when I was working for a silicon vendor was using employing maintainers as evidence of good software support for shiny new features on Linux, both internally and externally. That's obviously somewhat situation specific but it's one route.
Quoted 10 lines · Guenter Roeck
Quoted 8 lines · Jason Cooper
Quoted 1 line · Peter Hüwe
"I've been a kernel reviewer and tester" -- meh, who cares
Show me a concrete example where that has been expressed. I've had the exact opposite experience. Typically I've had to tone down the expectations of others.
Lucky you.
Well, my point wasn't to brag, but I think you knew that.
I'd hope that my experience isn't isolated, and if it is, why?
Quoted 9 lines
In my experience, code reviews often don't get much attention by project managers responsible for commercial projects. If anything, quite the opposite. The Linux kernel development culture is quite different.
Linux kernel:
"Thanks a lot for reviewing my code and making it better".
Commercial:
"Why do your reviews always take such a long time ? You are holding up the release!"
These are responses to reviews during employment. I was referring to, perhaps not clearly, the hiring process.
Quoted 2 lines
Granted, that doesn't happen everywhere, but I have seen it more than once, and I would content that this kind of culture is pretty widely spread.
wrt actual code reviews, I agree.
Quoted 3 lines
Of course, one might
argue that joining an affected company might not be a good idea in the first place, but not everyone has that much flexibility or choice.
When interviewing potential engineers, folks who demonstrate regular, real contributions to open source projects move up a notch or two in my book. Because the applicant has then demonstrated an ability to work with others, at a distance, for the good of the project.
iow, working in open source projects demonstrates you know how to telecommute. For companies looking to hire engineers into telecommuting positions, open source contributors are much lower risk.
What percentage of the overall market is that? I dunno. But devs wanting to live in odd places have a better shot of finding jobs by becoming regular contributors to open source.
Quoted 5 lines
I am not saying that it would be a bad idea to give code reviewers more credit; quite the contrary. However, I think it would be wrong to assume or expect that giving reviewers more credit would improve their chances for employment. It would, however, result in reviewers feeling recognized for themselves, which is a good thing.
I think we can get more results for our efforts by bringing folks in to community events. Buy beers and so forth. I'll never forget the evening in San Diego drinking blended single-malt (?!) with Olof, Tony and others.
If I enjoy working with someone, I take them out for beers, spend *time* with them. This works a lot better that adding a bullet to an eval.
Quoted 6 lines
Why does it matter ? I had a discussion a while ago with the founder of one of the web sites providing product reviews. I suggested to give product reviewers some kind of monetary reward for their reviews, eg part of the advertising revenue created by the site. Feedback I got was that reviewers typically don't care about monetary rewards, but they do care about recognition and about their standing in the community.
Fully agree. And it argues my point, things which can be counted and accrued (money, tokens, Reviewed-by [1], etc) rarely have the desired affect. At the end of the day, there's no substitute for making genuine gestures. Invites to KS or other events, dinner, drinks, socialization.
The problem with doing that is it costs money. Who pays? Does the 17 year old in Poland have the money to fly to $event?
If we agree that:
a) increasing the opportunities for trial run contributors/reviewers
b) developing community by getting together regularly
c) collecting statistics to determine program efficacy
Are good targets, then I'd like to discuss putting together a program/proposal that we could take to LF. Something quantifiable, e.g. company X can 'sponsor' 5 newcomers over the next year for $Y. It includes, per newcomer, a travel allowance for one trip and a small sum for a piece of gear. Gear issuance is determined by the co-maintainer/established kernel dev working with the newcomer.
Events could be small, 2 day regional affairs, or 1 big annual get together. Or both. If we go with small and regional, we would need to include the cost of flying the relevant established devs to the event. Regional events could be hosted by Linux-friendly companies to reduce cost.
thx,
Jason.
[1] It's worth noting that I view the tags as a *responsibility*, not a reward. It informs a bug hunter which devs had a hand it creation / merging of the blamed commit. Overloading the tags has been discussed before, with much resistance.
Quoted 5 lines · Greg KH
I like this proposal, thanks for making it. I'd be glad to help talk about this issue as I spend a lot of time working on dragging companies and developers into our community. We have a real lack of ways that people who are "reasonably skilled yet don't know what to work on" can do more to help contribute to the kernel.
I think this *might* be something that the efforts to reduce the amount of out of tree embedded code can help with? A part of that effort is identifying areas that need fixing, there will be a large enough list I imagine. The hard part is always matching people up with things that they are interested in though.
Quoted 27 lines · Mark Brown
Quoted 10 lines · Laurent Pinchart
Quoted 2 lines · On Wednesday 08 July 2015 01:21:40 Peter Huewe wrote:
We are definitely short on reviewers and thus have mostly overloaded maintainers.
I was about to propose a related core topic.
The reviewing and maintainership process seems to have a hard time scaling to the amount of contributions we receive, to the point where even well known and respected kernel developers get discourages.
tl;dr - upstreaming support for out of tree SoCs is currently often hard and time consuming.
Quoted 4 lines
Throwing more maintainers, co-maintainers or sub-maintainers at the kernel won't magically solve this, as the more core developers a subsystem has the more difficult it will be for them to synchronize. I would like share experience about good practice rules that have proved to be effective.
Right. In the specific case of upstreaming out of tree SoCs it's often in a large part part that there's some massive technical debt in the out of tree code working around generic problems in mainline, things like missing features or subsystems. On the one hand those are the hardest bits to get solved upstream, but equally because they present generic issues they should be the easiest to collaborate on.
Quoted 4 lines
Tim Bird (CCed) has been working to try to get people together to try to analyze what's in the kernels people ship on product and see what we can do to bring that debt down, there's already some people starting to do some active work on this.
I'd like to include Sebastian Hesslebarth (maintainer of mach-berlin) in this discussion. Him and the free-electron's guys (Thomas, Gregory, etc) have a lot of valuable first hand experience in this topic.
thx,
Jason.
Quoted 11 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
-- Steve
Quoted 11 lines · On Wed, 8 Jul 2015 07:43:25 -0400 Josh Boyer <[email protected]> wrote:
In order to track this well, you need data from users. And therein lies one of the problems. The majority of users don't use kernel.org kernels. They use distro kernels. The distros have data and tools to help track bugs and regressions, but upstream is somewhat loathe to look at anything that starts with b and ends with zilla. Why? Because the data coming from users is often utterly junk. You get a kernel splat and a "I don't know why this happened." And frankly, I don't expect them to know why it happened either. Particularly when you have subsystems that are using
WARN_ONas a fixme comment and sprinkling them all over the damn place.
Just a note. I hate the use of WARN_ON()s in this case. I bitch quite loudly when I stumble across them (and I do often), because my ktest scripts I use to test my own patches will fail if a WARN_ON() is triggered.
At least if my test boxes have the hardware that does this, it wont last long, as I'm pretty good at bitching ;-)
-- Steve
Hey Jason
Quoted 7 lines
Quoted 4 lines
--> Maybe LF can organize something?
"Here is a small token of appreciation (t-shirt, cup) for spending countless hours on reviewing and testing stuff in the Linux kernel -- keep up the good work"How about "Here's an invite to the KS, because we value your opinion and would like you to take part in the process." ;-)
Personally I think that's also a valuable approach - but since KS space is limited maybe not so feasible. T-Shirts etc are easier :)
Peter
Quoted 15 lines · Steven Rostedt
Quoted 11 lines · On Wed, 8 Jul 2015 07:43:25 -0400 Josh Boyer <[email protected]> wrote:
In order to track this well, you need data from users. And therein lies one of the problems. The majority of users don't use kernel.org kernels. They use distro kernels. The distros have data and tools to help track bugs and regressions, but upstream is somewhat loathe to look at anything that starts with b and ends with zilla. Why? Because the data coming from users is often utterly junk. You get a kernel splat and a "I don't know why this happened." And frankly, I don't expect them to know why it happened either. Particularly when you have subsystems that are using
WARN_ONas a fixme comment and sprinkling them all over the damn place.
Quoted 7 lines
Just a note. I hate the use of WARN_ON()s in this case. I bitch quite loudly when I stumble across them (and I do often), because my ktest scripts I use to test my own patches will fail if a
WARN_ON()is triggered.At least if my test boxes have the hardware that does this, it wont last long, as I'm pretty good at bitching ;-)
Are you test boxes headless? Because i915 is littered with WARN and WARN_ON, to the point where we carry a patch in Fedora to quiet most of the state machine related ones. If you look at retrace and filter out all the proprietary oopses, i915 is always most of the top 10 kernel issues Fedora sees.
josh
Quoted 3 lines · Bjorn Helgaas
I wish I knew how to use patchwork better, or had a smarter workflow that could comprehend a series as a single entity. Patchwork is a lot of clicking, but I don't know anything better.
We're working on improving patchwork here to understand series and help out with auto-deprecating patches when new versions show up. Currently being tested internally and we plan to push to upstream ofc and deploy on freedesktop.org (since that's where all the drm/gfx folks hang out), but because of all the things going on it's really slow. Damien knows more, maybe we could push the current state to some git branch somewhere.
-Daniel
Signature · 3 lines
Daniel Vetter Software Engineer, Intel Corporation +41 (0) 79 365 57 48 - http://blog.ffwll.ch
Quoted 7 lines · Peter Huewe
Hey Jason
Quoted 4 lines
Quoted 4 lines
--> Maybe LF can organize something?
"Here is a small token of appreciation (t-shirt, cup) for spending countless hours on reviewing and testing stuff in the Linux kernel -- keep up the good work"
Quoted 5 lines
Quoted 2 lines
How about "Here's an invite to the KS, because we value your opinion and would like you to take part in the process." ;-)
Personally I think that's also a valuable approach - but since KS space is limited maybe not so feasible. T-Shirts etc are easier :)
Right, later on I said (or in another mail) "KS or other event".
T-shirts are a given. Coffee mugs, thumbdrives that are modifiable a-la bad-usb. It's all good. ;-)
The chromecasts that were given out two years ago directly resulted in mach-berlin/ ... So maybe we should be giving out HW that *isn't* supported by mainline.
thx,
Jason.
Quoted 7 lines · On Wednesday 08 July 2015 19:06:37 Mark Brown wrote:
Quoted 5 lines · Greg KH
I like this proposal, thanks for making it. I'd be glad to help talk about this issue as I spend a lot of time working on dragging companies and developers into our community. We have a real lack of ways that people who are "reasonably skilled yet don't know what to work on" can do more to help contribute to the kernel.
Quoted 5 lines
I think this *might* be something that the efforts to reduce the amount of out of tree embedded code can help with? A part of that effort is identifying areas that need fixing, there will be a large enough list I imagine. The hard part is always matching people up with things that they are interested in though.
There's also the issue of documentation. Datasheets for embedded SoCs are often not publicly available. Even when out-of-tree code exists, the lack of documentation makes it more difficult to understand it and port it to mainline. I've seen many such cases in practice for camera sensor drivers that are often provided by vendors with a small set (or even a single) hardcoded configurations, using large register address/value tables. Porting such a driver to the mainline APIs often require computing register values from parameters received through the subsystem API, which requires a good understanding of the hardware.
Signature · 3 lines
Regards, Laurent Pinchart
Hey Jason,
Quoted 21 lines
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.Here we need to have the correct mindset. Kernel development is hard, detailed work. It's very rewarding, but simply put, most people aren't cut out to do it. I view the dropout rate as a *good* thing. It's a _selection_ process more than a education/training process.
With most of the hard jobs in life, take a look at the training/education program, and you'll see it: 80% drop out rate? That's selection. Kernel work is one of those 'hard jobs'.
This is important to realize because it changes how we view recruitment. We shouldn't be trying to keep everybody we recruit. Rather, we should be giving more people trial runs and see how they work out as they learn the process.
Quoted 5 lines
iow, if an 80% drop out rate gives us the caliber of dev we need for the long term health of the community, then it's a numbers game. Say we saw 40 new people last year, which turned into 8 regular contributors. Now we want to double that. We can lower the standard to get 16 out of 40, yuck. Or, we can outreach to 80 for trial runs, and get 16.
I think that's an interesting take on the topic - although I'm not 100% whether I agree with everything. I agree that our goal is not to lower the standards, and also using more "trial runs".
However high standards should not be the reason to drive people away -- and especially not the reason not to keep good people interested.
Not only the bad people drop out, I've seen quite a lot of good devs vanish for good - and these should be the ones we also should try to keep - especially since I'm not sure whether we can allow such high drop out rates over a long time.
Quoted 4 lines
... but because we need
to bring in new blood *somewhere*. co-maintainer/reviewer is one of many possibilities. If we don't have enough slots for newcomers (especially on a trial basis), that's our fault.
Agreed.
Interesting discussion about this topic - thanks for your opinion!
Thanks,
Peter
Quoted 8 lines · Laurent Pinchart
Quoted 5 lines · On Wednesday 08 July 2015 19:06:37 Mark Brown wrote:
I think this *might* be something that the efforts to reduce the amount of out of tree embedded code can help with? A part of that effort is identifying areas that need fixing, there will be a large enough list I imagine. The hard part is always matching people up with things that they are interested in though.
Quoted 9 lines
There's also the issue of documentation. Datasheets for embedded SoCs are often not publicly available. Even when out-of-tree code exists, the lack of documentation makes it more difficult to understand it and port it to mainline. I've seen many such cases in practice for camera sensor drivers that are often provided by vendors with a small set (or even a single) hardcoded configurations, using large register address/value tables. Porting such a driver to the mainline APIs often require computing register values from parameters received through the subsystem API, which requires a good understanding of the hardware.
Yeah, if you're doing device support. The generic subsystem bits are less impacted by these issues, though you can't completely get away from it. Fortunately I don't think we've got a great shortage of problems that need addressing so there should be some things that are tractable!
Quoted 4 lines
The chromecasts that were given out two years ago directly resulted in mach-berlin/ ...
So maybe we should be giving out HW that *isn't*
supported by mainline.
+1 - also a nice idea. :)
Thanks,
Peter
Quoted 8 lines · On Wed, 8 Jul 2015 15:11:32 -0400 Josh Boyer <[email protected]> wrote:
Quoted 2 lines
At least if my test boxes have the hardware that does this, it wont last long, as I'm pretty good at bitching ;-)
Are you test boxes headless? Because i915 is littered with WARN and
WARN_ON, to the point where we carry a patch in Fedora to quiet most of the state machine related ones. If you look at retrace and filter out all the proprietary oopses, i915 is always most of the top 10 kernel issues Fedora sees.
Sadly, my bitching skills didn't work well here:
https://lkml.org/lkml/2015/5/7/867
Maybe I let it slide. ktest allows you to run PRE_BUILD scripts, and what I've gotten use to doing was adding:
PRE_BUILD = patch -p1 < fix.patch
POST_BUILD = git reset --hard
Where that fix.patch would include silencing those damn warnings.
As I was under the impression that this was unique to my test box (which happens to be a development machine).
Maybe I should tone my bitching skills again. This time with some backup ;-)
-- Steve
Quoted 62 lines · On Wednesday 08 July 2015 11:40:11 NeilBrown wrote:
Quoted 53 lines · On Tue, 07 Jul 2015 17:50:39 -0700 Guenter Roeck wrote:
Quoted 52 lines · Laurent Pinchart
Quoted 8 lines · On Wednesday 08 July 2015 01:21:40 Peter Huewe wrote:
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
I was about to propose a related core topic.
The reviewing and maintainership process seems to have a hard time scaling to the amount of contributions we receive, to the point where even well known and respected kernel developers get discourages.
Quoting http://www.spinics.net/lists/cpufreq/msg10609.html,
--------------------------------
Quoted 3 lines
I'm trying to convince management that one of the advantages of mainlining the port is that it is easier to switch to newer kernels. Do you agree with this assertion?
Yes and no. If you can get stuff upstream, it should make things easier.
The difficult bit - and time consuming bit - is getting code upstream. Even in my position, I'd suggest allowing about five years for that activity, and even then don't have expectations of getting everything upstream.
Frankly now, my advice to people would be to just not bother, it's *way* too much effort to get everything to an acceptable state, especially if the SoC has no support what so ever.
--------------------------------That's a very serious red warning in my opinion.
Throwing more maintainers, co-maintainers or sub-maintainers at the kernel won't magically solve this, as the more core developers a subsystem has the more difficult it will be for them to synchronize. I would like share experience about good practice rules that have proved to be effective.
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.Quoted 5 lines
Quoted 3 lines
We can't keep people interested if even maintainers get discouraged. Solving (or at least relieving) that problem won't be enough to keep people interested, but it's a prerequisite in my opinion.
Problem is multi-dimensional.
Indeed! I wonder if we can list the dimensions.
Quoted 7 lines
Variability: as you say, different people want different things, and
care to different degrees about them. 'checkpatch' and 'CodingStyle' help with some of that (though different people care differently about checkpatch). Maybe theMAINTAINERSfile could list the preferred Subject: line and checkpatch flags for each maintainer. Then we just need to herd all those wild-cats towards updating their maintainers entry.
I've seen maintainers who want to be CC'ed on every patch touching their subsystem, and others who prefer patches being sent to the mailing list only. That would be easy to express in MAINTAINERS and would already help in two fronts. It would lower the amount of noise for maintainers who base their work flow on mailing lists. It would also remove the need for submitters to decide whether to CC maintainers and prevent patches from falling through cracks when the decision is incorrect.
Quoted 9 lines
I feel there is a related issue that might be called "Policy", though maybe it is a separate issue. There are a lot of areas where the "right" thing to do from a design perspective isn't really clear. "devicetree" "driver model" "sysfs attributes" "system call or virtual filesystem" "socket or char-device" all come to mind as being areas where different intelligent people differ. To a large extent they don't really matter as long as there is consistency. In areas where Linus cares, he can force consistency (if he notices). But I think there are a lot of areas where he doesn't
Quoted 8 lines
care and so it is very hard to find something that is "right". If the maintainer can say "this is wrong, do it this way" then that is useful. But when all they can say is "uhm. this doesn't seem right but I'm not really sure" it is hard to make progress. I've had a couple of those recently, and could imagine myself saying that in some circumstances. So: a technical committee to resolves unclear questions of design. They are right, be definition, even when they are wrong.
Maintainers are already busy as it is, I can't imagine how a technical committee could scale. We tried it for device tree bindings by appointing DT maintainers, and we can't really say it was a success.
I don't see anything seriously wrong with maintainers being honest and telling they don't know. Sometimes a task requires getting off the beaten tracks, that's just the way it is. Maintainers are not supposed to have answers for every question.
What bothers me more is the situation where patches get submitted, reviewed and updated several times, and then another developer notices the activity and requests a completely different approach. If that approach is bogus it's easy to dismiss it, but if it isn't the submitter will quite often get discouraged, and time will be wasted. I wonder if we could improve that situation, maybe with mechanisms that would make it easier for developers/reviewers to notice development activities they care about. I doubt I'm the only one who can't find time to follow all the mailing lists relevant to the subsystems I work with.
Quoted 5 lines
Busy-ness: maintainers are busy people. Some tools can help with that,
some tools can hinder it. There is no way to find if your maintainer is annoyed at you or just busy (I respond much the same way in both conditions). A social network tools that tells everyone "Neil's current state is: grumpy".
Would you really update that status when you get grumpy ? Maybe we need a brain reading device to automate the process ;-)
Quoted 50 lines
Competence: I don't mean "in-" here. But maintainers tend to get to
be maintainers because they were good at something else, and not good enough at hiding from the "maintainer" role. There is a paradox here as a maintainer must be good at saying "No", but if they were they might never have agreed to become a maintainer. Is the kernel community big enough that we need "professional maintainers" (other than GregKH and akpm)? People who can sift the wheat for that chaff, know enough about most subsystems that they can make sensible comments and recommendations, and have the patience to shepherd things along.
People who have the authority to bypass the technical maintainer if said maintainer isn't being responsive.Other dimensions?
NeilBrown
Quoted 33 lines
Every maintainer has a different style and different preferences. Even after being a maintainer for multiple years, I find it all but impossible to get it right for every maintainer if I submit a patch for some random subsystem. There may be minor coding style differences, subject line differences, or something else that is really cosmetic. Just finding the preferences for a specific subsystem can be challenging and time consuming.
For my part, if I get such a patch, I try to remain friendly and either fix up whatever I dislike myself (if I have the time and it is truly cosmetic), or I ask for a respin. Some maintainers less than friendly in such situations, assume that everyone who doesn't know the perfect style for a given subsystem are clueless, and respond accordingly. Not really encouraging.
It happened several times to me that a maintainer rejected one of my patches for less than obvious reasons. Sure, I could spend the time and try to convince the maintainer to accept it. Unfortunately, I don't always have the time to do that. In once recent case, where I did spend the time, and I thought the maintainer had agreed to accept the patch, I ended up getting an automated patchwork email telling me that the patch was deferred indefinitely. Not really encouraging either.
Essentially it takes a lot of time by submitters to gain the trust of maintainers - and that may even be the case if the submitter is also a maintainer. Not everyone has that much time (and/or patience).
Is there anything we can do about that ? I honestly don't know. I know I can be quite stubborn myself, after all, so I can't really complain and try to take away the right of others to be just as stubborn as I might be. After all, I don't want to be forced to accept a patch from some other maintainer either if I think it is wrong. But am open to suggestions.
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 5 lines · On Wednesday 08 July 2015 21:19:27 Daniel Vetter wrote:
Quoted 3 lines · Bjorn Helgaas
I wish I knew how to use patchwork better, or had a smarter workflow that could comprehend a series as a single entity. Patchwork is a lot of clicking, but I don't know anything better.
Quoted 7 lines
We're working on improving patchwork here to understand series and help out with auto-deprecating patches when new versions show up. Currently being tested internally and we plan to push to upstream ofc and deploy on freedesktop.org (since that's where all the drm/gfx folks hang out), but because of all the things going on it's really slow. Damien knows more, maybe we could push the current state to some git branch somewhere.
I implemented support for auto-delegating patches to developers based on the files touched by the patch, using regular expressions. We're using this for the media subsystem, but I've never found^H^H^H^H^Htook the time to push the changes upstream. Would anyone be interested in that ?
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 12 lines · On Wednesday 08 July 2015 14:53:15 Steven Rostedt wrote:
Quoted 10 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
Quoted 8 lines
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
Reviewed-by or Acked-by metrics are unfortunately very easy to game. If we could make them more robust, we could publish statistics as we do for commits authorship (http://remword.com/kps_result/ for instance) and start mentioning people's names in kernel development reports. That might not be much, but it could help reviewers feeling valued for their work.
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 1 line · On Wed, 08 Jul 2015 22:56:38 +0300 Laurent Pinchart…
Reviewed-by or Acked-by metrics are unfortunately very easy to game. If we
I'm not worried about Acked-by, as that (to me anyway) is just a maintainer telling other maintainers that they are fine with the change, and they are OK with it going in via another tree.
I also sometimes give an Acked-by, as a "I took a quick look, and it looks good to me". I only add a Reviewed-by tag if I took enough effort to understand every part of the patch as if I wrote it myself.
-- Steve
Guenter Roeck
Reviewed-by Edsel MurphyQuoted 10 lines · Steven Rostedt
Quoted 6 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 9 lines
Quoted 5 lines
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
Except for the following, they are always reliable and can be trusted.
Seriously, it does happen that I send Reviewed-by: or Acked-by: feedback if a patch is just fine as-is. What do you expect the reviewer to do in such a case ?
Thanks,
Guenter
Quoted 5 lines · Steven Rostedt
Quoted 1 line · On Wed, 08 Jul 2015 22:56:38 +0300 Laurent Pinchart…
Reviewed-by or Acked-by metrics are unfortunately very easy to game. If we
Quoted 7 lines
I'm not worried about Acked-by, as that (to me anyway) is just a maintainer telling other maintainers that they are fine with the change, and they are OK with it going in via another tree.
I also sometimes give an Acked-by, as a "I took a quick look, and it looks good to me". I only add a Reviewed-by tag if I took enough effort to understand every part of the patch as if I wrote it myself.
I do that too and that's my understanding of what the tag is for.
However, some people treat it as a this-patch-looks-good-to-me tag.
But regardless of what tags you use, if you say something along the lines of:
- I like A (because of X).
- I don't like B (because of Y).
- C will break things because of Z.
in your review, every maintainer will be grateful for that. I'd like people doing that kind of stuff to be recognized in some special way, because that's really really helpful (and we need it).
Honestly, I'm not sure how to make that happen.
Thanks,
Rafael
Quoted 27 lines · Peter Huewe
Quoted 21 lines
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.Here we need to have the correct mindset. Kernel development is hard, detailed work. It's very rewarding, but simply put, most people aren't cut out to do it. I view the dropout rate as a *good* thing. It's a _selection_ process more than a education/training process.
With most of the hard jobs in life, take a look at the training/education program, and you'll see it: 80% drop out rate? That's selection. Kernel work is one of those 'hard jobs'.
This is important to realize because it changes how we view recruitment. We shouldn't be trying to keep everybody we recruit. Rather, we should be giving more people trial runs and see how they work out as they learn the process.
Quoted 5 lines
iow, if an 80% drop out rate gives us the caliber of dev we need for the long term health of the community, then it's a numbers game. Say we saw 40 new people last year, which turned into 8 regular contributors. Now we want to double that. We can lower the standard to get 16 out of 40, yuck. Or, we can outreach to 80 for trial runs, and get 16.
Quoted 6 lines
I think that's an interesting take on the topic - although I'm not 100% whether I agree with everything. I agree that our goal is not to lower the standards, and also using more "trial runs".
However high standards should not be the reason to drive people away -- and especially not the reason not to keep good people interested.
Sure, I'm not suggesting anything like testing or anything formal. Merely that everyone understand there's an attrition rate, and that's *ok*.
Recruitment, imo, isn't about trying to keep everyone that tries. Rather it's about opening the doors and providing real opportunities for more people to contribute.
Quoted 4 lines
Not only the bad people drop out, I've seen quite a lot of good devs vanish for good - and these should be the ones we also should try to keep - especially since I'm not sure whether we can allow such high drop out rates over a long time.
I'd love to hear some specific examples, links to email threads so we can quantify this. I suspect a lot of it is: "I scratched the itch, and didn't have anything else I wanted to add. Then daily life took me away."
Which is the hard part about qualified people. They're busy. :-)
Perhaps this can help direct the outreach portion. Should we focus on students who have stretches of downtime? That certainly has pluses and minuses.
thx,
Jason.
Quoted 35 lines · Jason Cooper
Quoted 27 lines · Peter Huewe
Quoted 21 lines
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.Here we need to have the correct mindset. Kernel development is hard, detailed work. It's very rewarding, but simply put, most people aren't cut out to do it. I view the dropout rate as a *good* thing. It's a _selection_ process more than a education/training process.
With most of the hard jobs in life, take a look at the training/education program, and you'll see it: 80% drop out rate? That's selection. Kernel work is one of those 'hard jobs'.
This is important to realize because it changes how we view recruitment. We shouldn't be trying to keep everybody we recruit. Rather, we should be giving more people trial runs and see how they work out as they learn the process.
Quoted 5 lines
iow, if an 80% drop out rate gives us the caliber of dev we need for the long term health of the community, then it's a numbers game. Say we saw 40 new people last year, which turned into 8 regular contributors. Now we want to double that. We can lower the standard to get 16 out of 40, yuck. Or, we can outreach to 80 for trial runs, and get 16.
Quoted 6 lines
I think that's an interesting take on the topic - although I'm not 100% whether I agree with everything. I agree that our goal is not to lower the standards, and also using more "trial runs".
However high standards should not be the reason to drive people away -- and especially not the reason not to keep good people interested.
Quoted 7 lines
Sure, I'm not suggesting anything like testing or anything formal. Merely that everyone understand there's an attrition rate, and that's *ok*.
Recruitment, imo, isn't about trying to keep everyone that tries. Rather it's about opening the doors and providing real opportunities for more people to contribute.
The opportunities are there, but in addition to the opportunities themselves people need some incentives to use them. It's all about their time which they can spend in many ways, some of them more rewarding than others.
If they don't have an incentive, an opportunity itself may not be sufficient.
Thanks,
Rafael
Quoted 5 lines · Daniel Vetter
Quoted 3 lines · Bjorn Helgaas
I wish I knew how to use patchwork better, or had a smarter workflow that could comprehend a series as a single entity. Patchwork is a lot of clicking, but I don't know anything better.
Quoted 7 lines
We're working on improving patchwork here to understand series and help out with auto-deprecating patches when new versions show up. Currently being tested internally and we plan to push to upstream ofc and deploy on freedesktop.org (since that's where all the drm/gfx folks hang out), but because of all the things going on it's really slow. Damien knows more, maybe we could push the current state to some git branch somewhere.
I'd be interested in that if you can publish it somewhere.
At the moment I have a very hacky script that tries to recognise a series on the client, which usually works, but not always.
cheers
Quoted 21 lines · Guenter Roeck
Quoted 10 lines · Steven Rostedt
Quoted 6 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 9 lines
Quoted 5 lines
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
Quoted 7 lines
Except for the following, they are always reliable and can be trusted.
Reviewed-by Edsel Murphy <[email protected]>Seriously, it does happen that I send Reviewed-by: or Acked-by: feedback if a patch is just fine as-is. What do you expect the reviewer to do in such a case ?
There's almost always something you can say.
Even if it's a trivial patch, eg. a spelling fix, as the reviewer you should be confirming that only the spelling fix happened, ie. no other changes slipped into the diff. And so you can say that.
If it's more complex than a spelling fix then there's usually something you can comment on.
There might be times when all you can say is "Yep, logic looks right" which might seem redundant, but personally I'd prefer to see that than just a plain Reviewed-by.
cheers
Quoted 7 lines · Jason Cooper
Quoted 4 lines · Peter Huewe
Not only the bad people drop out, I've seen quite a lot of good devs vanish for good - and these should be the ones we also should try to keep - especially since I'm not sure whether we can allow such high drop out rates over a long time.
Quoted 6 lines
I'd love to hear some specific examples, links to email threads so we can quantify this. I suspect a lot of it is: "I scratched the itch, and didn't have anything else I wanted to add. Then daily life took me away."
Which is the hard part about qualified people. They're busy. :-)
Hopefully I'm not one of the "bad people", and I don't reallly consider myself a "drop out". But, I am someone that recently (i.e. since the last KS) extracted himself from a maintainer role. It seems like I should have something to add here...
I was the wireless maintainer for roughly seven years. My situation may be a bit unique in that I was always more of a "Linux guy" than a "wireless guy", and most of the contributors were bigger experts in the technology itself than I ever was. That was fine for a while, but over time that became less and less comfortable for me. I've never really heard anyone else express that sentiment, so this is probably not a widespread concern...
The bigger concern was that while I was wrangling everyone else's wireless patches, I had less and less time to do useful work elsewhere in the kernel. I definitely have heard other maintainers express similar complaints, so this seems like a relatively common concern. It would be good to find and promote maintainer organizations within subsystems that are less likely to monopolize the mainainer's development time. Previously we have had discussions of how the TIP tree is run, but I'm not sure that works well in every case. Are there other working models for this?
I guess I'm suggesting the opposite of a "professional maintainer". Some people thrive at being the center of a subsystem, as I did for some time with wireless. But burnout is a problem, and I think we can limit some of that if somehow we can encourage less expansive roles for individual maintainers.
John
Signature · 2 lines
John W. Linville Someday the world will need a hero, and you [email protected] might be all we have. Be ready.
Quoted 7 lines · John W. Linville
I guess I'm suggesting the opposite of a "professional maintainer". Some people thrive at being the center of a subsystem, as I did for some time with wireless. But burnout is a problem, and I think we can limit some of that if somehow we can encourage less expansive roles for individual maintainers.
I hear you.
However, having individual maintainers with a high level of responsibility and sense of ownership is one of the reasons why the Linux kernel development model works as well as it does.
In a corporate environment, there is often no sense of ownership in a specific piece of code. Quite often there _is_ no owner. As a result, engineers don't feel the need to keep the code clean. They need to make a change, they make it, they move on. The code gets more and more messy and buggy over time, and no one really cares.
Whatever we change, we need to make sure this doesn't happen with the Linux kernel, or it will fall apart quickly.
Guenter
Quoted 10 lines · Rafael J. Wysocki
Quoted 9 lines · Steven Rostedt
Quoted 1 line · On Wed, 08 Jul 2015 22:56:38 +0300 Laurent Pinchart…
Reviewed-by or Acked-by metrics are unfortunately very easy to game. If we
I'm not worried about Acked-by, as that (to me anyway) is just a maintainer telling other maintainers that they are fine with the change, and they are OK with it going in via another tree.
Quoted 5 lines
Quoted 3 lines
I also sometimes give an Acked-by, as a "I took a quick look, and it looks good to me". I only add a Reviewed-by tag if I took enough effort to understand every part of the patch as if I wrote it myself.
I do that too and that's my understanding of what the tag is for.
That seems to dilute the value of Acked-by. Acked-by requires a review, although the example statement of "yep, looks good to me" in SubmittingPatches is a lot less stringent than the "Reviewer's statement of oversight" that is attached to the Reviewed-by tag.
"I took a quick look" is not what I would like to encourage for reviews.
Would the "Cc:" tag be a more appropriate tag in this case? (Described in the same section as Acked-by in SubmittingPatches.) Or maybe SubmittingPatches needs to change to match reality?
SubmittingPatches:
Acked-by: is not as formal as Signed-off-by:. It is a record that the acker has at least reviewed the patch and has indicated acceptance. Hence patch mergers will sometimes manually convert an acker's "yep, looks good to me" into an Acked-by: (but note that it is usually better to ask for an explicit ack).
Then the next paragraph also allows a subsystem maintainer to acknowledge just that subsystem's part of a multiple subsystem patch.
Quoted 9 lines
However, some people treat it as a this-patch-looks-good-to-me tag.
But regardless of what tags you use, if you say something along the lines of:
- I like A (because of X).
- I don't like B (because of Y).
- C will break things because of Z.
Quoted 8 lines
in your review, every maintainer will be grateful for that. I'd like people doing that kind of stuff to be recognized in some special way, because that's really really helpful (and we need it).
Honestly, I'm not sure how to make that happen.
Thanks,
Rafael
- Frank
Quoted 15 lines · Guenter Roeck
Quoted 7 lines · John W. Linville
I guess I'm suggesting the opposite of a "professional maintainer". Some people thrive at being the center of a subsystem, as I did for some time with wireless. But burnout is a problem, and I think we can limit some of that if somehow we can encourage less expansive roles for individual maintainers.
I hear you.
However, having individual maintainers with a high level of responsibility and sense of ownership is one of the reasons why the Linux kernel development model works as well as it does.
Quoted 8 lines
In a corporate environment, there is often no sense of ownership in a specific piece of code. Quite often there _is_ no owner. As a result, engineers don't feel the need to keep the code clean. They need to make a change, they make it, they move on. The code gets more and more messy and buggy over time, and no one really cares.
Whatever we change, we need to make sure this doesn't happen with the Linux kernel, or it will fall apart quickly.
That is a good point, and I agree in principle. I would _not_ want to see any sort of "everyone can commit" model. Still, I think there might be ways to spread the maintainership load a bit wider.
I guess the suggestion becomes a deeper maintainer hierarchy where maintainers only pull from sub-maintainers, and sub-maintainers handle individual patches and smaller pull requests from contributors. This is essentially the model used for wireless. That introduces the problem of increased patch merge latency, for which I have no good suggestions...
John
Signature · 2 lines
John W. Linville Someday the world will need a hero, and you [email protected] might be all we have. Be ready.
Quoted 12 lines · Michael Ellerman
Quoted 11 lines · Guenter Roeck
Quoted 10 lines · Steven Rostedt
Quoted 6 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I don't expect my Reviewed-by tag with no extra comments to carry much weight if I send it to a maintainer who does not know me.
But if I have a history of good reviews to a specific maintainer, then why should I have to add a message that says: Yes, I really, really did review the patch. I truly mean that the patch "has been reviewed and found acceptable according to the Reviewer's Statement" as listed in SubmittingPatches.
And I read Steve's qualification of "don't trust ... _much_" as being consistent with what I am saying, so I'm fine with that. The point I want to make is that a Reviewed-by tag without comments should not always be assumed to be without meaning or value.
Quoted 11 lines
Quoted 9 lines
Quoted 1 line
Except for the following, they are always reliable and can be trusted.
Reviewed-by Edsel Murphy <[email protected]>Seriously, it does happen that I send Reviewed-by: or Acked-by: feedback if a patch is just fine as-is. What do you expect the reviewer to do in such a case ?
There's almost always something you can say.
And there is a time to not nit-pick a patch to death.
If my comment will not result in a significantly better patch, then I am wasting the patch submitter's time, and the time of everyone else on the mail list that will have to read my comment, and potentially have to read and review a new spin of the patch.
Reviewed-by does not mean that I believe the patch is perfect and could not possibly be improved. From the "Reviewer's statement of oversight":
(c) While there may be things that could be improved with this submission, I believe that it is, at this time, (1) a worthwhile modification to the kernel, and (2) free of known issues which would argue against its inclusion.
Quoted 11 lines
Even if it's a trivial patch, eg. a spelling fix, as the reviewer you should be confirming that only the spelling fix happened, ie. no other changes slipped into the diff. And so you can say that.
If it's more complex than a spelling fix then there's usually something you can comment on.
There might be times when all you can say is "Yep, logic looks right" which might seem redundant, but personally I'd prefer to see that than just a plain Reviewed-by.
"Yep, logic looks right" actually seems like a useful comment, because it tells me that the reviewer probably does not understand the full context, but the code is self consistent and does not have any obvious problems. So I will not think that the review is complete.
-Frank
Quoted 9 lines · John W. Linville
The bigger concern was that while I was wrangling everyone else's wireless patches, I had less and less time to do useful work elsewhere in the kernel. I definitely have heard other maintainers express similar complaints, so this seems like a relatively common concern. It would be good to find and promote maintainer organizations within subsystems that are less likely to monopolize the mainainer's development time. Previously we have had discussions of how the TIP tree is run, but I'm not sure that works well in every case. Are there other working models for this?
arm-soc is ran a bit like TIP, but not identically. It's usually Arnd and I who handle most of it, with Kevin Kilman stepping in in particular when Arnd goes on paternity leave.
On a whole, I can say that Arnd seems to have time left to deal with other parts of the kernel and posting patches, since he spends most or all of his work on upstream stuff while it's mostly a side activity for me.
One thing that we're doing that's quite helpful is that we hand off and mostly time-slice our maintainership, which means you get to be off from it for a while every now and then. That's different from TIP where they instead tend to have areas of the kernel that each co-maintainer focuses on. The last couple of months I've been overly busy with work and life and I've stepped away shortly, which our model makes fairly easy to do. I'm re-engaging now though, since Arnd is out on paternity leave again so me and Kevin are looking after things through the fall.
We also don't engage all that much with developers directly -- mostly new lead developers/maintainers on new platforms and people upstreaming new SoC families. Most of the day to day work is delegated to per-vendor maintainers below us and we work with them on the back end and merge their branches.
I think we've talked about how we handle our work in the past, but I'd be happy to elaborate more (here over email or elsewhere) if anyone wants to learn more about what we've found to work pretty well for us.
-Olof
Quoted 15 lines · Frank Rowand
Quoted 5 lines · Michael Ellerman
Quoted 4 lines · Guenter Roeck
Quoted 2 lines · Steven Rostedt
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I don't expect my Reviewed-by tag with no extra comments to carry much weight if I send it to a maintainer who does not know me.
But if I have a history of good reviews to a specific maintainer, then why should I have to add a message that says: Yes, I really, really did review the patch. I truly mean that the patch "has been reviewed and found acceptable according to the Reviewer's Statement" as listed in SubmittingPatches.
Quoted 4 lines
And I read Steve's qualification of "don't trust ... _much_" as being consistent with what I am saying, so I'm fine with that. The point I want to make is that a Reviewed-by tag without comments should not always be assumed to be without meaning or value.
Indeed, and when I'm the one dealing with applying the patches it's actually helpful to not have extra text that needs reading and thinking about when applying things if I trust whoever did the review. Past history as a reviewer is much more important than any verbiage around the review and review that consists of a simple tag takes seconds to read.
Quoted 4 lines
Quoted 3 lines
Quoted 3 lines
Seriously, it does happen that I send Reviewed-by: or Acked-by: feedback if a patch is just fine as-is. What do you expect the reviewer to do in such a case ?
Quoted 8 lines
Quoted 1 line
There's almost always something you can say.
And there is a time to not nit-pick a patch to death.
If my comment will not result in a significantly better patch, then I am wasting the patch submitter's time, and the time of everyone else on the mail list that will have to read my comment, and potentially have to read and review a new spin of the patch.
Very much so.
Quoted 20 lines · John W. Linville
Quoted 7 lines · Jason Cooper
Quoted 4 lines · Peter Huewe
Not only the bad people drop out, I've seen quite a lot of good devs vanish for good - and these should be the ones we also should try to keep - especially since I'm not sure whether we can allow such high drop out rates over a long time.
Quoted 6 lines
I'd love to hear some specific examples, links to email threads so we can quantify this. I suspect a lot of it is: "I scratched the itch, and didn't have anything else I wanted to add. Then daily life took me away."
Which is the hard part about qualified people. They're busy. :-)
Hopefully I'm not one of the "bad people", and I don't reallly consider myself a "drop out". But, I am someone that recently (i.e. since the last KS) extracted himself from a maintainer role. It seems like I should have something to add here...
Quoted 7 lines
I was the wireless maintainer for roughly seven years. My situation may be a bit unique in that I was always more of a "Linux guy" than a "wireless guy", and most of the contributors were bigger experts in the technology itself than I ever was. That was fine for a while, but over time that became less and less comfortable for me. I've never really heard anyone else express that sentiment, so this is probably not a widespread concern...
I've certainly found this to be the case for me where my little corner of the kernel, platform-drivers-x86, is basically an integration point for many other subsystems, such as rfkill, backlight, input, etc. with a lot of ACPI thrown in the mix. I also never have the hardware to be able to do any testing myself. I'm 100% dependent on my submitters for any testing beyond build and static analysis.
Quoted 8 lines
The bigger concern was that while I was wrangling everyone else's wireless patches, I had less and less time to do useful work elsewhere in the kernel. I definitely have heard other maintainers express similar complaints, so this seems like a relatively common concern. It would be good to find and promote maintainer organizations within subsystems that are less likely to monopolize the mainainer's development time.
For me, the concern is that I'm basically acting as a pro-bono proxy for various vendors who don't maintain drivers for the products. So speaking of recruitment, we could use the vendors to get more involved with the drivers for their platforms. Some, Dell and Toshiba most notably, have been providing more documentation, fortunately.
Quoted 9 lines
Previously we have had discussions of how the
TIP tree is run, but I'm not sure that works well in every case. Are there other working models for this?I guess I'm suggesting the opposite of a "professional maintainer". Some people thrive at being the center of a subsystem, as I did for some time with wireless. But burnout is a problem, and I think we can limit some of that if somehow we can encourage less expansive roles for individual maintainers.
Something along these lines is probably relevant to a number of subsystems where the professional maintainer is problematic since some to all of the content is of no interest to the employer (unless it's the LF).
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 30 lines · Frank Rowand
Quoted 12 lines · Michael Ellerman
Quoted 11 lines · Guenter Roeck
Quoted 10 lines · Steven Rostedt
Quoted 6 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I don't expect my Reviewed-by tag with no extra comments to carry much weight if I send it to a maintainer who does not know me.
But if I have a history of good reviews to a specific maintainer, then why should I have to add a message that says: Yes, I really, really did review the patch. I truly mean that the patch "has been reviewed and found acceptable according to the Reviewer's Statement" as listed in SubmittingPatches.
Quoted 5 lines
And I read Steve's qualification of "don't trust ... _much_" as being consistent with what I am saying, so I'm fine with that. The point I want to make is that a Reviewed-by tag without comments should not always be assumed to be without meaning or value.
Absolutely agree.
It looks like we have yet another set of diverging maintainer expectations. Some maintainers will expect me to provide an extra comment, which I'll have to phrase carefully to avoid it being misinterpreted as "I just glanced at the code and didn't find an obvious issue with it". Others will get annoyed at me providing the extra comment.
Guenter
Quoted 71 lines · Laurent Pinchart
Quoted 62 lines · On Wednesday 08 July 2015 11:40:11 NeilBrown wrote:
Quoted 53 lines · On Tue, 07 Jul 2015 17:50:39 -0700 Guenter Roeck wrote:
Quoted 52 lines · Laurent Pinchart
Quoted 8 lines · On Wednesday 08 July 2015 01:21:40 Peter Huewe wrote:
Hi,
In order to continue our traditions I would like to propose again the topic of recruitment, but this time not only limiting to the hobbyists market.
We are definitely short on reviewers and thus have mostly overloaded maintainers.
I was about to propose a related core topic.
The reviewing and maintainership process seems to have a hard time scaling to the amount of contributions we receive, to the point where even well known and respected kernel developers get discourages.
Quoting http://www.spinics.net/lists/cpufreq/msg10609.html,
--------------------------------
Quoted 3 lines
I'm trying to convince management that one of the advantages of mainlining the port is that it is easier to switch to newer kernels. Do you agree with this assertion?
Yes and no. If you can get stuff upstream, it should make things easier.
The difficult bit - and time consuming bit - is getting code upstream. Even in my position, I'd suggest allowing about five years for that activity, and even then don't have expectations of getting everything upstream.
Frankly now, my advice to people would be to just not bother, it's *way* too much effort to get everything to an acceptable state, especially if the SoC has no support what so ever.
--------------------------------That's a very serious red warning in my opinion.
Throwing more maintainers, co-maintainers or sub-maintainers at the kernel won't magically solve this, as the more core developers a subsystem has the more difficult it will be for them to synchronize. I would like share experience about good practice rules that have proved to be effective.
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.Quoted 5 lines
Quoted 3 lines
We can't keep people interested if even maintainers get discouraged. Solving (or at least relieving) that problem won't be enough to keep people interested, but it's a prerequisite in my opinion.
Problem is multi-dimensional.
Indeed! I wonder if we can list the dimensions.
Quoted 7 lines
Variability: as you say, different people want different things, and
care to different degrees about them. 'checkpatch' and 'CodingStyle' help with some of that (though different people care differently about checkpatch). Maybe theMAINTAINERSfile could list the preferred Subject: line and checkpatch flags for each maintainer. Then we just need to herd all those wild-cats towards updating their maintainers entry.
Quoted 7 lines
I've seen maintainers who want to be CC'ed on every patch touching their subsystem, and others who prefer patches being sent to the mailing list only. That would be easy to express in
MAINTAINERSand would already help in two fronts. It would lower the amount of noise for maintainers who base their work flow on mailing lists. It would also remove the need for submitters to decide whether to CC maintainers and prevent patches from falling through cracks when the decision is incorrect.
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodings
All of these are distractions from reviewing the code. I'm often on version 3 of a series before I'm actually reviewing content.
I raised this in Dusseldorf with the PREEMPT_RT crowd, and I'll do so here too, although I suspect it will be met with quite a bit of opposition. I believe our tooling and processes are good at helping our top level maintainers scale - which is absolutely critical to the success of Linux - but they inhibit scaling out and attracting new developers, reviewers, etc.
Our most productive maintainers and contributors, in my understanding, often are able to spend most of their time on their upstream Linux kernel work. They have been doing it for a decade or more and have a lot of custom written tools to help make the processes scale for their particular needs. This is great!
However, we have a lot of tribal knowledge regarding how to interact successfully with the development model. So much so that many of our lesser maintainers (like myself) spend a lot of our time as a bridge or proxy to upstream development, which is too opaque and even enigmatic for them to get into.
To be a successful contributor, a developer can't just be a capable C developer with a deep knowledge of their particular product and the surrounding subsystems, they also have to setup all kinds of email tooling which is harder and harder to do every year. These tools are typically special-purpose for Linux development because their corporate solution is incompatible. I just spent a day writing perl scripts to test my email against vger's silent drop policies and bisecting the delta between mutt and my git request-pull based automatically generated email to discover the missing header required for vger to deliver my pull requests to the list. Developers need to be RFC 2822 savvy and have a rather deep understanding of SMTP, procmail. Combine that with an infinite number of ways to accidentally annoy people on the list, from character encoding, content-type, line length, etc. and the new developer who likely has many other responsibilities beyond upstreaming their code or reviewing someone else's code, has a lot of obstacles to overcome that have nothing to do with the code in question.
While I once found our process to be a measure of the exacting quality of the Linux kernel development process, I am coming to view it as an obstacle to scaling out.
I am looking to make some changes in my subsystem. I've requested patchwork to be enabled, and I'll create a for-review branch and solicit help there. I already leverage 0-day, but I think it would be great to have something which parses patches submitted to LKML and tests the 8 items above and more and automatically responds to the submitter. Nobody should have to spend their time on those things.
Looking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
I suspect this won't be a particularly popular view, but I spend enough time as a proxy for competant developers for whom the existing processes are a major obstacle to getting fully involved, that I think it's worth raising them.
Sorry Laurant, perhaps this should have been a new topic - but I think it fits with the recruitment subject.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 16 lines · Steven Rostedt
Quoted 11 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
Quoted 8 lines
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
Agreed. Unless there is commentary accompanying the review, it doesn't add a lot. While the nod of approval builds incremental confidence, the true measure of a review is a resulting change to the patch for the better. Of course, a good review takes the same amount of time regardless of if a change is required.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 36 lines · Michael Ellerman
Quoted 21 lines · Guenter Roeck
Quoted 10 lines · Steven Rostedt
Quoted 6 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 9 lines
Quoted 5 lines
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
Quoted 7 lines
Except for the following, they are always reliable and can be trusted.
Reviewed-by Edsel Murphy <[email protected]>Seriously, it does happen that I send Reviewed-by: or Acked-by: feedback if a patch is just fine as-is. What do you expect the reviewer to do in such a case ?
There's almost always something you can say.
Even if it's a trivial patch, eg. a spelling fix, as the reviewer you should be confirming that only the spelling fix happened, ie. no other changes slipped into the diff. And so you can say that.
Quoted 6 lines
If it's more complex than a spelling fix then there's usually something you can comment on.
There might be times when all you can say is "Yep, logic looks right" which might seem redundant, but personally I'd prefer to see that than just a plain Reviewed-by.
Agreed. I have this same conversation about commit messages. I don't care if it's a whitespace fix, if it is worth patching, building, testing, and submitting, it is worth writing a sentence about why you did it and what it's for. The same applies to a review. What did you confirm? Did you build it? Run checkpatch or some other static analysis? I think I'm also guilty of a one-line review now and then, but I'll be sure to include detail in the future.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 36 lines · Guenter Roeck
Quoted 30 lines · Frank Rowand
Quoted 12 lines · Michael Ellerman
Quoted 11 lines · Guenter Roeck
Quoted 10 lines · Steven Rostedt
Quoted 6 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I don't expect my Reviewed-by tag with no extra comments to carry much weight if I send it to a maintainer who does not know me.
But if I have a history of good reviews to a specific maintainer, then why should I have to add a message that says: Yes, I really, really did review the patch. I truly mean that the patch "has been reviewed and found acceptable according to the Reviewer's Statement" as listed in SubmittingPatches.
Quoted 5 lines
And I read Steve's qualification of "don't trust ... _much_" as being consistent with what I am saying, so I'm fine with that. The point I want to make is that a Reviewed-by tag without comments should not always be assumed to be without meaning or value.
Quoted 7 lines
Absolutely agree.
It looks like we have yet another set of diverging maintainer expectations. Some maintainers will expect me to provide an extra comment, which I'll have to phrase carefully to avoid it being misinterpreted as "I just glanced at the code and didn't find an obvious issue with it". Others will get annoyed at me providing the extra comment.
Why would a couple lines of context be any harder to deal with than all the meta-data that comes along with an email including a Reviewed-by?
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
No matter what we ask people to type, the system can be gamed so long as we (a) use automated systems, and (b) we're transparent what the automated system uses as a signal about what's a valid review versus a garbage review. This is basically the same problem that Google has when trying to deal with SEO folks who are trying to game the search algorithm, and it's not really a soluble problem unless you have a lot of people constantly working on refining the system and adjusting in response to humans who are trying to attack the system.
And if there are companies who are using reviews, or signed-off-by counts as a basis of performance reviews, humans *will* be incentivized to game the system, regardless of what the kernel summit program committee might be doing to use these systems.
(Although I will say there is one person who I've consistently downgraded *because* it's obvious s/he has been sending lots of trivial patches, and while that person may (or may not) have changed, it's still human nature that I assume that this person's scores are inflated. And this is true of whoever sends huge number of checkpatch or coccinelle generated or inspired patches. So people should be aware that attempts to game the system can backfire, when people start imposing informal "manual penalties" to their evaluation of that particular person. Which is exactly what happens in the Search Engine Optimization world, by the way....)
- Ted
Quoted 56 lines · Darren Hart
Quoted 11 lines · Laurent Pinchart
Quoted 9 lines · On Wednesday 08 July 2015 11:40:11 NeilBrown wrote:
Indeed! I wonder if we can list the dimensions.
Variability: as you say, different people want different things, and
care to different degrees about them. 'checkpatch' and 'CodingStyle' help with some of that (though different people care differently about checkpatch). Maybe theMAINTAINERSfile could list the preferred Subject: line and checkpatch flags for each maintainer. Then we just need to herd all those wild-cats towards updating their maintainers entry.Quoted 7 lines
I've seen maintainers who want to be CC'ed on every patch touching their subsystem, and others who prefer patches being sent to the mailing list only. That would be easy to express in
MAINTAINERSand would already help in two fronts. It would lower the amount of noise for maintainers who base their work flow on mailing lists. It would also remove the need for submitters to decide whether to CC maintainers and prevent patches from falling through cracks when the decision is incorrect.I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsAll of these are distractions from reviewing the code. I'm often on version 3 of a series before I'm actually reviewing content.
I raised this in Dusseldorf with the
PREEMPT_RTcrowd, and I'll do so here too, although I suspect it will be met with quite a bit of opposition. I believe our tooling and processes are good at helping our top level maintainers scale - which is absolutely critical to the success of Linux - but they inhibit scaling out and attracting new developers, reviewers, etc.Our most productive maintainers and contributors, in my understanding, often are able to spend most of their time on their upstream Linux kernel work. They have been doing it for a decade or more and have a lot of custom written tools to help make the processes scale for their particular needs. This is great!
However, we have a lot of tribal knowledge regarding how to interact successfully with the development model. So much so that many of our lesser maintainers (like myself) spend a lot of our time as a bridge or proxy to upstream development, which is too opaque and even enigmatic for them to get into.
[...]
Quoted 11 lines
I am looking to make some changes in my subsystem. I've requested patchwork to be enabled, and I'll create a for-review branch and solicit help there. I already leverage 0-day, but I think it would be great to have something which parses patches submitted to LKML and tests the 8 items above and more and automatically responds to the submitter. Nobody should have to spend their time on those things.
Looking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
I would love to see this. I don't think it makes sense for the flow from subsystem maintainers to Linus or similar to use these tools; anyone capable of saying "please pull" *probably* doesn't need most of this. However, for people who primarily interact with maintainers via patch mails, some kind of automated CI bot, integrated with Gerrit or github or similar, would filter out a substantial number of painful bits before they show up.
Consider a set of scripts or services that could easily be wired into either a Gerrit install or a GitHub hook, so that rather than spending time sorting out SMTP and basic patch formatting, people could git push to a repository branch they control, get automated feedback on what needs fixing, and when all of the mechanical issues are sorted out that same service can help them send a properly formatted mail series (with cover letter) to the right set of people.
It would take some work to initially set up, but the result should actually save maintainer time by avoiding the need to comment on mechanical correctness issues.
That same bot could fairly easily be wired to a "test" mailing list, capturing mailed patch series and running them through the same tests, so that people comfortable with the email part of the workflow could mail patches to that list to have them automatically checked *before* mailing LKML. And unlike mailing LKML, there would be no stigma attached to iterating and sending multiple mails to that list while trying to get the details right.
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
- Josh Triplett
Quoted 20 lines · Darren Hart
Quoted 19 lines · Steven Rostedt
Quoted 11 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
Quoted 8 lines
Quoted 5 lines
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
Agreed. Unless there is commentary accompanying the review, it doesn't add a lot.
No, that is not always true. If I see a naked "reviewed-by" from a person who's been working on the subsystem quite a bit and shown a good judgement it is enough for me. I do not need them to find something to nitpick over so that there is "meat" to the review.
Quoted 3 lines
While the nod of approval builds incremental confidence, the true measure of a review is a resulting change to the patch for the better. Of course, a good review takes the same amount of time regardless of if a change is required.
Thanks.
Signature · 1 line
Dmitry
Quoted 39 lines · Darren Hart
Quoted 38 lines · Guenter Roeck
Quoted 30 lines · Frank Rowand
Quoted 12 lines · Michael Ellerman
Quoted 11 lines · Guenter Roeck
Quoted 10 lines · Steven Rostedt
Quoted 6 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I don't expect my Reviewed-by tag with no extra comments to carry much weight if I send it to a maintainer who does not know me.
But if I have a history of good reviews to a specific maintainer, then why should I have to add a message that says: Yes, I really, really did review the patch. I truly mean that the patch "has been reviewed and found acceptable according to the Reviewer's Statement" as listed in SubmittingPatches.
Quoted 5 lines
And I read Steve's qualification of "don't trust ... _much_" as being consistent with what I am saying, so I'm fine with that. The point I want to make is that a Reviewed-by tag without comments should not always be assumed to be without meaning or value.
Absolutely agree.
Quoted 9 lines
Quoted 5 lines
It looks like we have yet another set of diverging maintainer expectations. Some maintainers will expect me to provide an extra comment, which I'll have to phrase carefully to avoid it being misinterpreted as "I just glanced at the code and didn't find an obvious issue with it". Others will get annoyed at me providing the extra comment.
Why would a couple lines of context be any harder to deal with than all the meta-data that comes along with an email including a Reviewed-by?
No, but that isn't the point. I use patchwork, which takes care of automatically adding all tags and removing the clutter around it, so I don't really care one way or another.
I neither expect reviewers to provide additional comments, nor do I mind if they do provide such comments. I see comments as beneficial on complex reviews, or if a reviewer had an earlier concern which was addressed by feedback from the submitter but did not result in code changes. Overall comments may be either positive or neutral to me, depending on the context. But a Reviewed-by: tag does not have less value to me just because there is no comment associated with it.
I _do_ expect reviewers to understand the statement they are making by providing a Reviewed-by: tag, just as I expect patch submitters to understand the statement they are making with their Signed-off: tag.
The point I am making, which has been confirmed by this e-mail exchange, is that reviewers have to be careful of yet another detail when providing feedback on a patch. Some, like you and Stephen, may expect me to provide some feedback around a Reviewed-by: tag, while others may get annoyed at me for providing such additional feedback.
Guenter
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would make the 0-day-bot chain only do sensible things. My undestanding is that the 0-day bot now has Coccinelle integration though, not so sure of the rest, if the pipline is already set up then the auto-patch-merging is the only next step needed, can patchwork do that for some subsystem already set up ? It should just be a matter of adding a git repo and adding it to the list of 0-day bot git repos.
Luis
Quoted 98 lines · Josh Triplett
Quoted 56 lines · Darren Hart
Quoted 11 lines · Laurent Pinchart
Quoted 9 lines · On Wednesday 08 July 2015 11:40:11 NeilBrown wrote:
Indeed! I wonder if we can list the dimensions.
Variability: as you say, different people want different things, and
care to different degrees about them. 'checkpatch' and 'CodingStyle' help with some of that (though different people care differently about checkpatch). Maybe theMAINTAINERSfile could list the preferred Subject: line and checkpatch flags for each maintainer. Then we just need to herd all those wild-cats towards updating their maintainers entry.Quoted 7 lines
I've seen maintainers who want to be CC'ed on every patch touching their subsystem, and others who prefer patches being sent to the mailing list only. That would be easy to express in
MAINTAINERSand would already help in two fronts. It would lower the amount of noise for maintainers who base their work flow on mailing lists. It would also remove the need for submitters to decide whether to CC maintainers and prevent patches from falling through cracks when the decision is incorrect.I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsAll of these are distractions from reviewing the code. I'm often on version 3 of a series before I'm actually reviewing content.
I raised this in Dusseldorf with the
PREEMPT_RTcrowd, and I'll do so here too, although I suspect it will be met with quite a bit of opposition. I believe our tooling and processes are good at helping our top level maintainers scale - which is absolutely critical to the success of Linux - but they inhibit scaling out and attracting new developers, reviewers, etc.Our most productive maintainers and contributors, in my understanding, often are able to spend most of their time on their upstream Linux kernel work. They have been doing it for a decade or more and have a lot of custom written tools to help make the processes scale for their particular needs. This is great!
However, we have a lot of tribal knowledge regarding how to interact successfully with the development model. So much so that many of our lesser maintainers (like myself) spend a lot of our time as a bridge or proxy to upstream development, which is too opaque and even enigmatic for them to get into.
[...]
Quoted 11 lines
I am looking to make some changes in my subsystem. I've requested patchwork to be enabled, and I'll create a for-review branch and solicit help there. I already leverage 0-day, but I think it would be great to have something which parses patches submitted to LKML and tests the 8 items above and more and automatically responds to the submitter. Nobody should have to spend their time on those things.
Looking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
I would love to see this. I don't think it makes sense for the flow from subsystem maintainers to Linus or similar to use these tools; anyone capable of saying "please pull" *probably* doesn't need most of this. However, for people who primarily interact with maintainers via patch mails, some kind of automated CI bot, integrated with Gerrit or github or similar, would filter out a substantial number of painful bits before they show up.
Consider a set of scripts or services that could easily be wired into either a Gerrit install or a GitHub hook, so that rather than spending time sorting out SMTP and basic patch formatting, people could git push to a repository branch they control, get automated feedback on what needs fixing, and when all of the mechanical issues are sorted out that same service can help them send a properly formatted mail series (with cover letter) to the right set of people.
It would take some work to initially set up, but the result should actually save maintainer time by avoiding the need to comment on mechanical correctness issues.
That same bot could fairly easily be wired to a "test" mailing list, capturing mailed patch series and running them through the same tests, so that people comfortable with the email part of the workflow could mail patches to that list to have them automatically checked *before* mailing LKML. And unlike mailing LKML, there would be no stigma attached to iterating and sending multiple mails to that list while trying to get the details right.
Quoted 3 lines
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Pretty sure you said that better than I did :-)
The git submission mechanism makes a lot of sense (that's a bare minimum to working with Linux) and +1000 on avoiding the stigma of a "mechanical" failure on LKML.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 66 lines · Guenter Roeck
Quoted 39 lines · Darren Hart
Quoted 38 lines · Guenter Roeck
Quoted 30 lines · Frank Rowand
Quoted 12 lines · Michael Ellerman
Quoted 11 lines · Guenter Roeck
Quoted 10 lines · Steven Rostedt
Quoted 6 lines · On Wed, 08 Jul 2015 09:00:32 +0100 [email protected] wrote:
Quoted 5 lines
We can alter that somewhat. We used to run a Maintainers lottery for the kernel summit ... we could instead offer places based on the number of Reviewed-by: tags ... we have all the machinery to calculate that. I know an invitation to the kernel summit isn't a huge incentive, but it's a useful one.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
Sounds like a good idea to me, though it would only effect a tiny percentage of our reviewers. I suppose publishing a short list of the top n% of reviewers from which the lottery runs might give some recognition.
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I don't expect my Reviewed-by tag with no extra comments to carry much weight if I send it to a maintainer who does not know me.
But if I have a history of good reviews to a specific maintainer, then why should I have to add a message that says: Yes, I really, really did review the patch. I truly mean that the patch "has been reviewed and found acceptable according to the Reviewer's Statement" as listed in SubmittingPatches.
Quoted 5 lines
And I read Steve's qualification of "don't trust ... _much_" as being consistent with what I am saying, so I'm fine with that. The point I want to make is that a Reviewed-by tag without comments should not always be assumed to be without meaning or value.
Absolutely agree.
Quoted 9 lines
Quoted 5 lines
It looks like we have yet another set of diverging maintainer expectations. Some maintainers will expect me to provide an extra comment, which I'll have to phrase carefully to avoid it being misinterpreted as "I just glanced at the code and didn't find an obvious issue with it". Others will get annoyed at me providing the extra comment.
Why would a couple lines of context be any harder to deal with than all the meta-data that comes along with an email including a Reviewed-by?
No, but that isn't the point. I use patchwork, which takes care of automatically adding all tags and removing the clutter around it, so I don't really care one way or another.
I neither expect reviewers to provide additional comments, nor do I mind if they do provide such comments. I see comments as beneficial on complex reviews, or if a reviewer had an earlier concern which was addressed by feedback from the submitter but did not result in code changes. Overall comments may be either positive or neutral to me, depending on the context. But a Reviewed-by: tag does not have less value to me just because there is no comment associated with it.
I _do_ expect reviewers to understand the statement they are making by providing a Reviewed-by: tag, just as I expect patch submitters to understand the statement they are making with their Signed-off: tag.
Quoted 8 lines
The point I am making, which has been confirmed by this e-mail exchange, is that reviewers have to be careful of yet another detail when providing feedback on a patch. Some, like you and Stephen, may expect me to provide some feedback around a Reviewed-by: tag, while others may get annoyed at me for providing such additional feedback.
Guenter
I do agree that a plain reviewed-by from an established contributor adds value without additional comment.
Stepping back a bit though, We are talking about Recruitment, which implies new people. In my opinion, encouraging new people to provide context is a good idea.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 9 lines · Theodore Ts'o
No matter what we ask people to type, the system can be gamed so long as we (a) use automated systems, and (b) we're transparent what the automated system uses as a signal about what's a valid review versus a garbage review. This is basically the same problem that Google has when trying to deal with SEO folks who are trying to game the search algorithm, and it's not really a soluble problem unless you have a lot of people constantly working on refining the system and adjusting in response to humans who are trying to attack the system.
Quoted 5 lines
And if there are companies who are using reviews, or signed-off-by counts as a basis of performance reviews, humans *will* be incentivized to game the system, regardless of what the kernel summit program committee might be doing to use these systems.
While this may be correct in some circumstances, there are also companies which do just the opposite, especially when it comes to reviews. At least for my part I still have to encounter a company where "provides excellent and thorough code reviews" can be found as positive statement in a performance review.
Earlier it was discussed how to improve the recognition of reviewers. Your comments seems to suggest the opposite, and may actually discourage reviewers. Why should I review Linux kernel code if that is seen by some as me trying to "game" the system ?
I used to submit some more or less random cleanup patches into various areas of the kernel, just for fun, because I liked doing it, and because I needed some distraction. I stopped doing it after I realized that this may be seen as "gaming the system". Nowadays I only submit such random patches to fix build errors or real bugs. Would I continue to do that if I get accused of trying to game the system ? Probably not.
I am not much if at all concerned with people gaming the system to improve their standing, whereever that may be. I am much more concerned that we may drive people off by accusing them to just submit patches or reviews to game the system. At the end this is our loss, not theirs. If their work results in better code, who cares what their motivation might be ? And who are we to judge their motivation ?
Quoted 11 lines
(Although I will say there is one person who I've consistently downgraded *because* it's obvious s/he has been sending lots of trivial patches, and while that person may (or may not) have changed, it's still human nature that I assume that this person's scores are inflated. And this is true of whoever sends huge number of checkpatch or coccinelle generated or inspired patches. So people should be aware that attempts to game the system can backfire, when people start imposing informal "manual penalties" to their evaluation of that particular person. Which is exactly what happens in the Search Engine Optimization world, by the way....)
That may be true for some people, but at the same time I think statements like the above might discourage people who just like cleaning up code for fun. There are several of those working on cleaning up the Linux kernel, and I truly appreciate their efforts.
Guenter
Quoted 8 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
- Josh Triplett
Quoted 5 lines · On Thu, Jul 09, 2015 at 02:00:59PM -0700, [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 8 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Yeah true, Fengguang, is that an option?
Luis
Quoted 5 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 8 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Not sure to understand. Isn't it better to have the most feedback possible?
julia
Quoted 5 lines
Quoted 3 lines
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Yeah true, Fengguang, is that an option?
But you save some compute cycles on Fengguang's farm for serializing the process for developers. Letting the robots try some compilations may find some more issues with the patch series.
-Tony
Quoted 16 lines · Julia Lawall
Quoted 14 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 12 lines · Luis R. Rodriguez
On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] w rote:
Quoted 3 lines
Bonus if this is also wired into the 0day bot, so that you also find out
if you introduce a new warning or error.No reason to make bots do stupid work, if we really wanted to consider
this a bit more seriously the pipeline could be:mailing-list | coccinelle coccicheck| smatch | sparse | 0-day
-bot
Quoted 7 lines
Quoted 4 lines
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural
issues, don't bother with full-scale testing, just reject".Not sure to understand. Isn't it better to have the most feedback possible?
If we're talking about encouraging new contributors, then probably not.
You don't necessarily want a lot of negative feedback from different places, all at once.
Signature · 2 lines
David Woodhouse Open Source Technology Centre [email protected] Intel Corporation
Theodore Ts'o
Reviewed-by John Q. RandomQuoted 5 lines · Guenter Roeck
Earlier it was discussed how to improve the recognition of reviewers. Your comments seems to suggest the opposite, and may actually discourage reviewers. Why should I review Linux kernel code if that is seen by some as me trying to "game" the system ?
So I were designing an initial system that automatically scored reviewers, I'd be looking to see, from a holistic point of view, how many reviews were zero-length:
... and nothing else,
.... versus how many reviews had specific comments on various different portions of the patch. If possible, the automated system would try to distinguish between comments that were just pointing out whitespace issues (which would be a slight positive) with comments that point out genuine design issues (this will be really hard to do in an automated fashion, but a very sophisticated nueral network[1] mgiht be able to hack it).
I might also try using some kind scheme that counted the number of words in a review (stripping out lines of patch or commit description that the review was a reply to), etc. But of course, if it was public knowledge that the system was just stripping out the original e-mail, and then just doing a "wc -w", then people would game the system by adding list of random words at the bottom of the review.
And, of course, I'd have the system give a huge negative score if a commit that got a "LGTM" positive review caused a bug that required the patch to be reverted. *That* signal, at least, would be hard to game, and would hopefuly encourage people to actually take time reviewing a commit, and not blindly slapping a reviewed-by on a commit they don't understand.
You see? It's not that reviews in and of themselves are attempts to game the system ---- just so long as they are genuine reviews. If there is evidence that the reviews are issued within seconds of the original patch going out, with a Reviewed-by: line and nothing else, what would *you* think about the quality of that review?
Quoted 4 lines
That may be true for some people, but at the same time I think statements like the above might discourage people who just like cleaning up code for fun. There are several of those working on cleaning up the Linux kernel, and I truly appreciate their efforts.
Sure, but that's not the people who (in my opinion as a program committee member) should be attendingt he Kernel Summit, where we want people who are genuinely clueful about technical and policy issues, and not people like (for example) Nick Krause.
Regards,
- Ted
[1] http://googleresearch.blogspot.com/2015/06/inceptionism-going-deeper-into-neural.html
Quoted 12 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodings
Quoted 2 lines
All of these are distractions from reviewing the code. I'm often on version 3 of a series before I'm actually reviewing content.
I don't think it's entirely appropriate to call all of those 'distractions'.
The "content" in question is a proposed change to the code base. Such a change requires a coherent commit message which will make sense when we look back at this commit in the future. We will need to understand what was happening and why, in order to fix it or tweak it for new circumstances.
Doing that is *not* a peculiarity of the Linux 'process'. It is basic engineering discipline, and it is *part* of the work. Just like the task of breaking a change down into incremental, bisectable commits — which I'm surprised wasn't in your list.
Yes, there are a lot of people who *lack* that basic engineering discipline, to the point where it *can* start to look like it's a Linux -only requirement. But it's not. And there's not a lot we can do if an "engineer" lacks it, short of educating them. That part isn't a process issue.
Likewise, compiler warnings. If your developers are actually *submitting* code with unresolved compiler warnings, again there's not a lot we can do to help them or you. Apart from confiscating their keyboard.
Coding style, again, isn't a Linux-specific thing. All large code bases attempt to have some kind of consistency to make the code readable, and anyone attempting to work on *any* code base should expect to become familiar with the idioms and conventions (and charset choice) of the code they're working on.
These *aren't* process issues, in my view. What you're saying with some of these is that you're having to do *basic* (non-Linux-specific) education of people who want to contribute code, and that *that* doesn't scale. Which is true, but it's hard to know how to address that, except with programs like GSoC etc.
Josh suggests that we should provide a service that people could push code to and 'get automated feedback on what needs fixing'... but isn't that what checkpatch was for? OK, a local tool can't cross-compile it for you on every platform we support, but it can do a lot of stuff short of that.
I do like the idea of a 'test' mailing list which receives patches and checks them for corruption though.
Signature · 2 lines
David Woodhouse Open Source Technology Centre [email protected] Intel Corporation
Quoted 53 lines · David Woodhouse
Quoted 12 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsQuoted 2 lines
All of these are distractions from reviewing the code. I'm often on version 3 of a series before I'm actually reviewing content.
I don't think it's entirely appropriate to call all of those 'distractions'.
The "content" in question is a proposed change to the code base. Such a change requires a coherent commit message which will make sense when we look back at this commit in the future. We will need to understand what was happening and why, in order to fix it or tweak it for new circumstances.
Doing that is *not* a peculiarity of the Linux 'process'. It is basic engineering discipline, and it is *part* of the work. Just like the task of breaking a change down into incremental, bisectable commits — which I'm surprised wasn't in your list.
Yes, there are a lot of people who *lack* that basic engineering discipline, to the point where it *can* start to look like it's a Linux -only requirement. But it's not. And there's not a lot we can do if an "engineer" lacks it, short of educating them. That part isn't a process issue.
Likewise, compiler warnings. If your developers are actually *submitting* code with unresolved compiler warnings, again there's not a lot we can do to help them or you. Apart from confiscating their keyboard.
Coding style, again, isn't a Linux-specific thing. All large code bases attempt to have some kind of consistency to make the code readable, and anyone attempting to work on *any* code base should expect to become familiar with the idioms and conventions (and charset choice) of the code they're working on.
These *aren't* process issues, in my view. What you're saying with some of these is that you're having to do *basic* (non-Linux-specific) education of people who want to contribute code, and that *that* doesn't scale. Which is true, but it's hard to know how to address that, except with programs like GSoC etc.
Quoted 8 lines
Josh suggests that we should provide a service that people could push code to and 'get automated feedback on what needs fixing'... but isn't that what checkpatch was for? OK, a local tool can't cross-compile it for you on every platform we support, but it can do a lot of stuff short of that.
I do like the idea of a 'test' mailing list which receives patches and checks them for corruption though.
Experience with interns suggests that most people can get it right, but that most people reequire a few tries to figure it out (mailer problems, proper subject line, meaning of ---, etc). So a test mailing list could be helpful.
julia
Quoted 10 lines · Julia Lawall
Quoted 8 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 7 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
Quoted 8 lines
Quoted 5 lines
Quoted 1 line
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Not sure to understand. Isn't it better to have the most feedback possible?
If 0-day has enough bandwidth, sure. However, if this is going to encourage a large number of new contributors to quickly iterate a pile of patches, many of which are likely to have basic procedural issues in the first few iterations, then that may waste quite a lot of build time in 0-day.
- Josh Triplett
Quoted 15 lines · Theodore Ts'o
Quoted 5 lines · Guenter Roeck
Earlier it was discussed how to improve the recognition of reviewers. Your comments seems to suggest the opposite, and may actually discourage reviewers. Why should I review Linux kernel code if that is seen by some as me trying to "game" the system ?
So I were designing an initial system that automatically scored reviewers, I'd be looking to see, from a holistic point of view, how many reviews were zero-length:
Reviewed-by John Q. Random <[email protected]>... and nothing else,
Quoted 7 lines
.... versus how many reviews had specific comments on various different portions of the patch. If possible, the automated system would try to distinguish between comments that were just pointing out whitespace issues (which would be a slight positive) with comments that point out genuine design issues (this will be really hard to do in an automated fashion, but a very sophisticated nueral network[1] mgiht be able to hack it).
That assumes the patch actually has issues. To use the reviews I do on RCU patches as an example, in a patch series, I might reply to a few patches with "here are some issues; with those fixed, Reviewed-by...", and then reply to the remaining unproblematic patches (individually or in aggregate) with just the Reviewed-by.
- Josh Triplett
Quoted 17 lines · On Thu, Jul 9, 2015 at 4:11 PM, <[email protected]> wrote:
Quoted 16 lines · Julia Lawall
Quoted 13 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 8 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
Quoted 2 lines
Not sure to understand. Isn't it better to have the most feedback possible?
If 0-day has enough bandwidth, sure. However, if this is going to encourage a large number of new contributors to quickly iterate a pile of patches, many of which are likely to have basic procedural issues in the first few iterations, then that may waste quite a lot of build time in 0-day.
I'm not being empathetic towards machines as they are not [yet] sentient, but has anyone estimated the average cost of a full 0-day test cycle on a full kernel tree? I'm all for using machines when available to due our bidding, but I was simply trying to consider how we can be more efficient about it. That's all.
Luis
Quoted 17 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 16 lines · Julia Lawall
Quoted 13 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 8 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
Quoted 2 lines
Not sure to understand. Isn't it better to have the most feedback possible?
If 0-day has enough bandwidth, sure. However, if this is going to encourage a large number of new contributors to quickly iterate a pile of patches, many of which are likely to have basic procedural issues in the first few iterations, then that may waste quite a lot of build time in 0-day.
My understanding was that there were plenty of computational resources available. I would think that a new contributor would like the most assurance possible that his next attempt would be successful, and thus would prefer to have all the information at once.
julia
Quoted 30 lines · David Woodhouse
Quoted 12 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsQuoted 2 lines
All of these are distractions from reviewing the code. I'm often on version 3 of a series before I'm actually reviewing content.
I don't think it's entirely appropriate to call all of those 'distractions'.
The "content" in question is a proposed change to the code base. Such a change requires a coherent commit message which will make sense when we look back at this commit in the future. We will need to understand what was happening and why, in order to fix it or tweak it for new circumstances.
Doing that is *not* a peculiarity of the Linux 'process'. It is basic engineering discipline, and it is *part* of the work. Just like the task of breaking a change down into incremental, bisectable commits — which I'm surprised wasn't in your list.
Quoted 5 lines
Yes, there are a lot of people who *lack* that basic engineering discipline, to the point where it *can* start to look like it's a Linux -only requirement. But it's not. And there's not a lot we can do if an "engineer" lacks it, short of educating them. That part isn't a process issue.
Fair enough. Agreed.
Small functional changes isn't something that is readily automated, and it's the kind of feedback I do expect to give as a maintainer. That's why it isn't on the list. I understand your point that some things that are on the list are just good SW Eng 101 material - in practice, it still wastes my time :-) as it can be automated.
Quoted 5 lines
Likewise, compiler warnings. If your developers are actually *submitting* code with unresolved compiler warnings, again there's not a lot we can do to help them or you. Apart from confiscating their keyboard.
In the simplest case, sure. However, it isn't uncommon for config fuzz testing or different compiler versions to result in compiler warnings that the original submitter could legitimately not seen. Right now my choice is to ignore their code or spend the time to educate - but either way I have to build it and find the error. That step could be automated.
Quoted 13 lines
Coding style, again, isn't a Linux-specific thing. All large code bases attempt to have some kind of consistency to make the code readable, and anyone attempting to work on *any* code base should expect to become familiar with the idioms and conventions (and charset choice) of the code they're working on.
These *aren't* process issues, in my view. What you're saying with some of these is that you're having to do *basic* (non-Linux-specific) education of people who want to contribute code, and that *that* doesn't scale. Which is true, but it's hard to know how to address that, except with programs like GSoC etc.
Quoted 8 lines
Josh suggests that we should provide a service that people could push code to and 'get automated feedback on what needs fixing'... but isn't that what checkpatch was for? OK, a local tool can't cross-compile it for you on every platform we support, but it can do a lot of stuff short of that.
I do like the idea of a 'test' mailing list which receives patches and checks them for corruption though.
I believe we're in agreement on some additional automation being available to a broader audience would catch more errors with less maintainer/reviewer time.
As to what should be expected from contributors... I don't know. I wish everyone was as meticulous as you and so many other kernel developers (it's one of the things I really appreciate about Linux kernel development), and something I personally strive for. The reality is, they aren't, and since we're talking about recruiting, my point was by implementing some of these things we can maintain our standards while reducing maintainer/reviewer overhead.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 3 lines · Darren Hart
since we're talking about recruiting, my point was by implementing some of these things we can maintain our standards while reducing maintainer/reviewer overhead.
Hopefully, yes. But people actually have to *use* the tools and services we provide. Like checkpatch.
Rather than seeing them as part of the problem.
Signature · 1 line
dwmw2
Quoted 30 lines · Julia Lawall
Quoted 17 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 16 lines · Julia Lawall
Quoted 13 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 8 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
Quoted 2 lines
Not sure to understand. Isn't it better to have the most feedback possible?
If 0-day has enough bandwidth, sure. However, if this is going to encourage a large number of new contributors to quickly iterate a pile of patches, many of which are likely to have basic procedural issues in the first few iterations, then that may waste quite a lot of build time in 0-day.
Quoted 4 lines
My understanding was that there were plenty of computational resources available. I would think that a new contributor would like the most assurance possible that his next attempt would be successful, and thus would prefer to have all the information at once.
Fair enough. Might as well go ahead with the full battery unless it becomes a problem.
- Josh Triplett
Quoted 7 lines · Darren Hart
Quoted 5 lines · Guenter Roeck
It looks like we have yet another set of diverging maintainer expectations. Some maintainers will expect me to provide an extra comment, which I'll have to phrase carefully to avoid it being misinterpreted as "I just glanced at the code and didn't find an obvious issue with it". Others will get annoyed at me providing the extra comment.
I guess I'm one of those you're thinking about here - annoyed is very strong, it's definitely not an active problem. If it's saying something out of the ordinary then it's adding value but a lot of patches really are just pretty routine.
Quoted 2 lines
Why would a couple lines of context be any harder to deal with than all the meta-data that comes along with an email including a Reviewed-by?
Personally it's the difference between one line of new text that can be read by pattern matching and new text which requires looking at the actual words. It's not the end of the world (and I'd go so far as to say it's actually a good thing if it's adding something) but in cases where I've got a big stack of things I've already looked at where I'm waiting for acks it does help make things a bit smoother.
Quoted 6 lines · On Thu, Jul 09, 2015 at 04:13:52PM -0700, [email protected] wrote:
That assumes the patch actually has issues. To use the reviews I do on RCU patches as an example, in a patch series, I might reply to a few patches with "here are some issues; with those fixed, Reviewed-by...", and then reply to the remaining unproblematic patches (individually or in aggregate) with just the Reviewed-by.
Right, that's why I talked about doing this on a holistic way. It's true that individual patches, and maybe even all of the patches in a patch series, might be *perfect*. But presumably that won't be true for **all** of the patches you review.
This is why creating a system to do patch reviewer ranking is so complicated. You need to do this by looking at the entire corpus of patches reviewed by the reviewer, so (for example) you can find out which patch reviewers are allowing bad patches to get through to Linus by giving a thumbs up to a patch that needed to be reverted.
(At $WORK, if someone creates a CL that causes a massive failure, it's not just the engineer who submitted the CL who is at fault, but also the reviewers who gave the CL a positive review --- and that's as it should be. Of course we also ask if there is something about the development and regression test environment that might be a systematic cause of problems, but if someone is consistently giving LGTM's without doing enough due diligence, that's a issue that ultimately need to be addressed by the engineer's manager. The question is how to deal with this kind of failure mode in an open source, volunteer world.)
- Ted
Quoted 9 lines · David Woodhouse
Quoted 3 lines · Darren Hart
since we're talking about recruiting, my point was by implementing some of these things we can maintain our standards while reducing maintainer/reviewer overhead.
Hopefully, yes. But people actually have to *use* the tools and services we provide. Like checkpatch.
Rather than seeing them as part of the problem.
Using checkpatch on patches before they are submitted are definitely part of the solution. Using "checkpatch --file" or coccinelle on files where you are not the maintainer or one of the core subsystem developers to inflate your patch count is (IMHO) part of the problem.
- Ted
Quoted 7 lines · On Thu, 9 Jul 2015 13:21:52 -0700 Dmitry Torokhov <[email protected]>…
Quoted 2 lines
Agreed. Unless there is commentary accompanying the review, it doesn't add a lot.
No, that is not always true. If I see a naked "reviewed-by" from a person who's been working on the subsystem quite a bit and shown a good judgement it is enough for me. I do not need them to find something to nitpick over so that there is "meat" to the review.
And this is where the problem lies. Every review by tag is different, and it really matters from who it's from. I've had people send me a "Reviewed-by" tag that I had no idea who it is from, and with no commentary. That to me is worthless.
But I've sent patches out and have asked people like Masami Hiramatsu to review it, and if he returns just a "Reviewed-by" with no commentary, I take that as a positive, and that he didn't find anything wrong with what I wrote. And I gladly add that tag as it has meaning to me.
It really does come down to the maintainer. They should only add a Reviewed-by tag from someone they trust, or from someone that has given them constructive criticisms for the patch. I really don't know how strict maintainers of other subsystems are with regard to adding those tags.
I personally don't add that tag unless I have done an extensive review of the patch. I don't want some stupid bug come back to a patch that has my Reviewed-by tag on it. But I have reviewed lots of patches where I haven't put enough effort into adding a RB tag. Perhaps I should just add "Looks-fine-to-me-by:" tag, stating I did a light review but not a thorough one. ;-)
-- Steve
Quoted 5 lines · Dmitry Torokhov
No, that is not always true. If I see a naked "reviewed-by" from a person who's been working on the subsystem quite a bit and shown a good judgement it is enough for me. I do not need them to find something to nitpick over so that there is "meat" to the review.
Absolutely. If I'm looking at a patch for ext4, and I see a bare
Reviewed-by: from Jan Kara, I treat that very differently compared to a Reviewed-by: coming from someone like Nick Krause.
The challenge is if we are using a scheme that uses some kind of automated counting of Reviewed-by lines, how do we make the system smart enough so it counts the former, but not the latter? Or worse, *encourages* more of the latter, which just adds more noise which actually increases the load on Maintainers, not decreases.
(Which is also my objection to people sending patches generated from "checkpatch --file" runs. Maybe it's fine in for staging code, but for other subsystems, it basically just means there are more patches that require review by someone clueful --- since sometimes "cleanup" patches from trolls actually introduce bugs.)
- Ted
Quoted 51 lines · Darren Hart
Quoted 30 lines · David Woodhouse
Quoted 12 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsQuoted 2 lines
All of these are distractions from reviewing the code. I'm often on version 3 of a series before I'm actually reviewing content.
I don't think it's entirely appropriate to call all of those 'distractions'.
The "content" in question is a proposed change to the code base. Such a change requires a coherent commit message which will make sense when we look back at this commit in the future. We will need to understand what was happening and why, in order to fix it or tweak it for new circumstances.
Doing that is *not* a peculiarity of the Linux 'process'. It is basic engineering discipline, and it is *part* of the work. Just like the task of breaking a change down into incremental, bisectable commits — which I'm surprised wasn't in your list.
Quoted 5 lines
Yes, there are a lot of people who *lack* that basic engineering discipline, to the point where it *can* start to look like it's a Linux -only requirement. But it's not. And there's not a lot we can do if an "engineer" lacks it, short of educating them. That part isn't a process issue.
Fair enough. Agreed.
Small functional changes isn't something that is readily automated, and it's the kind of feedback I do expect to give as a maintainer. That's why it isn't on the list. I understand your point that some things that are on the list are just good SW Eng 101 material - in practice, it still wastes my time :-) as it can be automated.
Quoted 5 lines
Likewise, compiler warnings. If your developers are actually *submitting* code with unresolved compiler warnings, again there's not a lot we can do to help them or you. Apart from confiscating their keyboard.
Quoted 5 lines
In the simplest case, sure. However, it isn't uncommon for config fuzz testing or different compiler versions to result in compiler warnings that the original submitter could legitimately not seen. Right now my choice is to ignore their code or spend the time to educate - but either way I have to build it and find the error. That step could be automated.
Yeah. That's why I have the bleeding-edge branch. :-)
Quoted 18 lines
Quoted 18 lines
Coding style, again, isn't a Linux-specific thing. All large code bases attempt to have some kind of consistency to make the code readable, and anyone attempting to work on *any* code base should expect to become familiar with the idioms and conventions (and charset choice) of the code they're working on.
These *aren't* process issues, in my view. What you're saying with some of these is that you're having to do *basic* (non-Linux-specific) education of people who want to contribute code, and that *that* doesn't scale. Which is true, but it's hard to know how to address that, except with programs like GSoC etc.
Josh suggests that we should provide a service that people could push code to and 'get automated feedback on what needs fixing'... but isn't that what checkpatch was for? OK, a local tool can't cross-compile it for you on every platform we support, but it can do a lot of stuff short of that.
Quoted 5 lines
Quoted 2 lines
I do like the idea of a 'test' mailing list which receives patches and checks them for corruption though.
I believe we're in agreement on some additional automation being available to a broader audience would catch more errors with less maintainer/reviewer time.
That service only requires somebody with a kernel.org account and enough time to apply *all* patches they get (except for the ones that don't apply, of course) and push the result out into a public git branch on a regular basis.
That might be a robot, but arguably not running on kernel.org for safety reasons.
Quoted 6 lines
As to what should be expected from contributors... I don't know. I wish everyone was as meticulous as you and so many other kernel developers (it's one of the things I really appreciate about Linux kernel development), and something I personally strive for. The reality is, they aren't, and since we're talking about recruiting, my point was by implementing some of these things we can maintain our standards while reducing maintainer/reviewer overhead.
With all tools/scripts/0-days/whatever in place there always is the time when *you* (the maintainer) have to decide whether or not to apply the patch (and sometimes when to apply it too), so you have to look at it and understand what it is doing.
Fortunately or not, no kind of software is able to understand things as of today, so you need a human for that job. And *that* really should be the job for reviewers (including maintainers in a reviewer role). All of the coding style/build errors/white space/etc is secondary in principle. However, people often request things to be cleaned up to start with, because those small details prevent them from being able to understand the general idea in the first place.
So the automation is only useful here as long as it helps patch submitters to get their work to the point at which it can be understood by a reviewer in a relatively short time. Otherwise, it is just not helpful in that respect.
For example, if someone sends me a patch that doesn't apply, but that I can easily understand and I think "Yeah, that's a good idea!", I may fix it up and make it build and so on just fine. But without understanding, I pretty much can't do anything with it even if it got all of the details perfect.
Thanks,
Rafael
Quoted 5 lines · David Woodhouse
Quoted 2 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
Quoted 8 lines
Quoted 8 lines
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodings
As far as I can tell for most of the bits of this that are tooling and create practical problems git send-email will avoid most of the issue and people do seem to have mostly adopted that, but perhaps that's a result of me seeing a different submitter base to you. I very rarely see anything that's serious enough to cause a practical problem except for CC issues that doesn't also come along with other substantial code quality problems.
Patch changelogs are the biggest thing I can see there that feels like a tooling problem to me since git send-email doesn't do anything at all, though it's not an issue I'm personally that concerned about (I do appreciate having them but I can often barely remember what issues I raised in the first place).
Quoted 10 lines
The "content" in question is a proposed change to the code base. Such a change requires a coherent commit message which will make sense when we look back at this commit in the future. We will need to understand what was happening and why, in order to fix it or tweak it for new circumstances.
Doing that is *not* a peculiarity of the Linux 'process'. It is basic engineering discipline, and it is *part* of the work. Just like the task of breaking a change down into incremental, bisectable commits — which I'm surprised wasn't in your list.
Judging by the history of many of the proprietary codebases I've had cause to look at the fact that these things are good engineering practice does not mean they're not unusual. :/
I have to say that I'm willing to cut people quite a large amount of slack on changelogs if I can understand the code and they obviously don't speak English that well, though in cases where I do that if I feel it's needed I will tend to fix up the changelog myself. It's not that common that it's needed but I do feel it's an effort worth making.
Quoted 4 lines
Likewise, compiler warnings. If your developers are actually *submitting* code with unresolved compiler warnings, again there's not a lot we can do to help them or you. Apart from confiscating their keyboard.
There's some that this is the case for but there's enough things that depend on configs or compiler versions that it's perfectly plausible that things build fine for the submitter in reasonable testing.
Quoted 5 lines
Josh suggests that we should provide a service that people could push code to and 'get automated feedback on what needs fixing'... but isn't that what checkpatch was for? OK, a local tool can't cross-compile it for you on every platform we support, but it can do a lot of stuff short of that.
aiaiai is pretty reasonable for going a step beyond here, I really do wish it played nicely with ccache though.
Quoted 2 lines
I do like the idea of a 'test' mailing list which receives patches and checks them for corruption though.
That would help a lot of people.
Quoted 11 lines · Theodore Ts'o
Quoted 5 lines · Dmitry Torokhov
No, that is not always true. If I see a naked "reviewed-by" from a person who's been working on the subsystem quite a bit and shown a good judgement it is enough for me. I do not need them to find something to nitpick over so that there is "meat" to the review.
Absolutely. If I'm looking at a patch for ext4, and I see a bare
Reviewed-by: from Jan Kara, I treat that very differently compared to a Reviewed-by: coming from someone like Nick Krause.
Quoted 5 lines
The challenge is if we are using a scheme that uses some kind of automated counting of Reviewed-by lines, how do we make the system smart enough so it counts the former, but not the latter? Or worse, *encourages* more of the latter, which just adds more noise which actually increases the load on Maintainers, not decreases.
The Reviewed-by: tags are added to commits by people who ckeck them in, ie. maintainers. They should be responsible for using those tags wisely.
If the maintainers exercise enough due dilligence in that area, as they do with the SoB tags, it actually should be OK to collect and publish Reviewed-by:
statistics too.
Quoted 5 lines
(Which is also my objection to people sending patches generated from "checkpatch --file" runs. Maybe it's fine in for staging code, but for other subsystems, it basically just means there are more patches that require review by someone clueful --- since sometimes "cleanup" patches from trolls actually introduce bugs.)
Or mindless cleanups for that matter. I completely agree here.
Thanks,
Rafael
Quoted 11 lines · Theodore Ts'o
Quoted 5 lines · Dmitry Torokhov
No, that is not always true. If I see a naked "reviewed-by" from a person who's been working on the subsystem quite a bit and shown a good judgement it is enough for me. I do not need them to find something to nitpick over so that there is "meat" to the review.
Absolutely. If I'm looking at a patch for ext4, and I see a bare
Reviewed-by: from Jan Kara, I treat that very differently compared to a Reviewed-by: coming from someone like Nick Krause.
Quoted 5 lines
The challenge is if we are using a scheme that uses some kind of automated counting of Reviewed-by lines, how do we make the system smart enough so it counts the former, but not the latter? Or worse, *encourages* more of the latter, which just adds more noise which actually increases the load on Maintainers, not decreases.
I suppose the scan should read the tags from what is committed, not from LKML, then the maintainers are responsible to include only meaningful tags in the commit history? You then of course run the risk of putting someone off by ignoring their work - and I'd rather err in favor of the reviewer (false positive).
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 5 lines · Rafael Wysocki
On Thursday, July 09, 2015 04:38:54 PM Darren Hart wrote:
So the automation is only useful here as long as it helps patch submitters to get their work to the point at which it can be understood by a reviewer in a relatively short time. Otherwise, it is just not helpful in that respect.
And that's the gist of what I'm getting at. Automation could help get things to a reviewable state so maintainers/reviewers spend less time on what Josh called "mechanical" errors, on things the submitter should have caught themselves, etc.
Quoted 4 lines
For example, if someone sends me a patch that doesn't apply, but that I can easily understand and I think "Yeah, that's a good idea!", I may fix it up and make it build and so on just fine. But without understanding, I pretty much can't do anything with it even if it got all of the details perfect.
Yes, of course.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 15 lines · Mark Brown
Quoted 5 lines · David Woodhouse
Quoted 2 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
Quoted 8 lines
Quoted 8 lines
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodings
Quoted 4 lines
As far as I can tell for most of the bits of this that are tooling and create practical problems git send-email will avoid most of the issue and people do seem to have mostly adopted that, but perhaps that's a result of me seeing a different submitter base to you. I very rarely
I was going to make the same comment - we all deal with a different group. I admittedly see a number of first time contributors looking to improve their particular laptop, rather than veteran sub-system developers (I also get people picking up major platform drivers and doing a great job).
Quoted 9 lines
see anything that's serious enough to cause a practical problem except for CC issues that doesn't also come along with other substantial code quality problems.
Patch changelogs are the biggest thing I can see there that feels like a tooling problem to me since git send-email doesn't do anything at all, though it's not an issue I'm personally that concerned about (I do appreciate having them but I can often barely remember what issues I raised in the first place).
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer spends enough time to make setting that all up worthwhile, but honestly, there are A LOT of ways to embarass yourself with git-send-email. So much so that I've written wrappers to it to protect people from it for the yocto project - and even myself for my kernel work.
Is that a good assumption? Are we talking about first-timers - or are we talking about getting current participants to do more review?
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 7 lines · Theodore Ts'o
Quoted 5 lines · Dmitry Torokhov
No, that is not always true. If I see a naked "reviewed-by" from a person who's been working on the subsystem quite a bit and shown a good judgement it is enough for me. I do not need them to find something to nitpick over so that there is "meat" to the review.
Quoted 7 lines
Absolutely. If I'm looking at a patch for ext4, and I see a bare
Reviewed-by: from Jan Kara, I treat that very differently compared to a Reviewed-by: coming from someone like Nick Krause.The challenge is if we are using a scheme that uses some kind of automated counting of Reviewed-by lines, how do we make the system smart enough so it counts the former, but not the latter?
I guess it's possible using various features of what the person has done in the past to devise a machine learning algorithm that could make this distinction.
julia
Quoted 16 lines
Or worse,
*encourages* more of the latter, which just adds more noise which actually increases the load on Maintainers, not decreases.(Which is also my objection to people sending patches generated from "checkpatch --file" runs. Maybe it's fine in for staging code, but for other subsystems, it basically just means there are more patches that require review by someone clueful --- since sometimes "cleanup" patches from trolls actually introduce bugs.)
- Ted
_______________________________________________
Ksummit-discuss mailing list [email protected]
https://lists.linuxfoundation.org/mailman/listinfo/ksummit-discuss
Am 9. Juli 2015 23:00:59 MESZ, schrieb [email protected]:
Quoted 8 lines · Luis R. Rodriguez
Quoted 1 line
On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected]
Quoted 1 line · wrote:
Quoted 1 line
Bonus if this is also wired into the 0day bot, so that you also
find out
Quoted 3 lines
Quoted 1 line
if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to
Quoted 8 lines
consider
Quoted 3 lines
this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
0-day already includes sparse, coccinelle and smatch ;) (and others)
I have a dedicated for-review and testing branch which is 0-day monitored and only if I don't hear negative from 0-day stuff moves to my -next branch.
Thanks
Peter
Signature · 1 line
Sent from my mobile
Quoted 5 lines · On Thu, 2015-07-09 at 14:00 -0700, [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 8 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
We already have this with the 0 day project. The only difference being the patch has to be in a tree for it to get tested. It's not impossible to imagine a bot that would pick up a patch, apply it (giving automated rejects as email replies), and leave it in for the 0 day tests to
assess ... sort of like patchwork but with an automated tree build. We
could periodically throw away the tree (say weekly) because the job of the bot would be to find initial rejects rather than build a workable tree.
James
Quoted 13 lines · David Woodhouse
Quoted 12 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodings
Quoted 5 lines
Quoted 2 lines
All of these are distractions from reviewing the code. I'm often on version 3 of a series before I'm actually reviewing content.
I don't think it's entirely appropriate to call all of those 'distractions'.
Thank you for writing this a lot more clearly than I had in my head.
Quoted 28 lines
The "content" in question is a proposed change to the code base. Such a change requires a coherent commit message which will make sense when we look back at this commit in the future. We will need to understand what was happening and why, in order to fix it or tweak it for new circumstances.
Doing that is *not* a peculiarity of the Linux 'process'. It is basic engineering discipline, and it is *part* of the work. Just like the task of breaking a change down into incremental, bisectable commits — which I'm surprised wasn't in your list.
Yes, there are a lot of people who *lack* that basic engineering discipline, to the point where it *can* start to look like it's a Linux -only requirement. But it's not. And there's not a lot we can do if an "engineer" lacks it, short of educating them. That part isn't a process issue.
Likewise, compiler warnings. If your developers are actually *submitting* code with unresolved compiler warnings, again there's not a lot we can do to help them or you. Apart from confiscating their keyboard.
Coding style, again, isn't a Linux-specific thing. All large code bases attempt to have some kind of consistency to make the code readable, and anyone attempting to work on *any* code base should expect to become familiar with the idioms and conventions (and charset choice) of the code they're working on.
Quoted 5 lines
These *aren't* process issues, in my view. What you're saying with some of these is that you're having to do *basic* (non-Linux-specific) education of people who want to contribute code, and that *that* doesn't scale. Which is true, but it's hard to know how to address that, except with programs like GSoC etc.
What we're also looking at here is adjusting the wetware / software boundary. The goal of checkpatch is the same: offload maintainer brain time onto automated software. But it's a double-edged sword. Now we see checkpatch-only patches. Was it a net-gain for maintainer relief? Or simply a shift in the type of annoyances?
I don't know. The lesson learned from checkpatch and other tools shouldn't be lost on any effort we try today. That's not to say we shouldn't try. Rather, we should try new processes and tooling, *and* establish sane goals for the same. "After 1 year of autotest@vger, we'll poll the maintainers and ask if they noticed a difference." This implies some sort of tag system so maintainers can trivially tell when a patch has cleared autotest@vger. Maybe:
Autotest-passed: https://autotest.kernel.org/2015/07/10/<cookie>
Depending on the proposed system, the goal can be more quantifiable, if needed.
Quoted 8 lines
Josh suggests that we should provide a service that people could push code to and 'get automated feedback on what needs fixing'... but isn't that what checkpatch was for? OK, a local tool can't cross-compile it for you on every platform we support, but it can do a lot of stuff short of that.
I do like the idea of a 'test' mailing list which receives patches and checks them for corruption though.
Agree. And in sensible cases, it can suggest a fix. e.g. "Missing S-o-b, please read the DCO [link]. If you agree, add your S-o-b to the end of the commit message. 'git commit -s ...' will add this for you."
wrt recruitment, It would be advisable for a few maintainers who are interested to be subscribed to autotest@vger to keep an eye on things and intervene if necessary.
thx,
Jason.
Quoted 36 lines · Darren Hart
Quoted 15 lines · Mark Brown
Quoted 5 lines · David Woodhouse
Quoted 2 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
Quoted 8 lines
Quoted 8 lines
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsQuoted 4 lines
As far as I can tell for most of the bits of this that are tooling and create practical problems git send-email will avoid most of the issue and people do seem to have mostly adopted that, but perhaps that's a result of me seeing a different submitter base to you. I very rarely
I was going to make the same comment - we all deal with a different group. I admittedly see a number of first time contributors looking to improve their particular laptop, rather than veteran sub-system developers (I also get people picking up major platform drivers and doing a great job).
Quoted 9 lines
see anything that's serious enough to cause a practical problem except for CC issues that doesn't also come along with other substantial code quality problems.
Patch changelogs are the biggest thing I can see there that feels like a tooling problem to me since git send-email doesn't do anything at all, though it's not an issue I'm personally that concerned about (I do appreciate having them but I can often barely remember what issues I raised in the first place).
Quoted 6 lines
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer spends enough time to make setting that all up worthwhile, but honestly, there are A LOT of ways to embarass yourself with git-send-email. So much so that I've written wrappers to it to protect people from it for the yocto project - and even myself for my kernel work.
git send-email --kernel *.patch ?
--kernel would go through each patch and auto-fills Cc based on MAINTAINERS. Amongst a few other things. Shallow threading, check/edit cover letter and so forth.
Or, we put a wrapper in ./scripts to accomplish the same.
Quoted 2 lines
Is that a good assumption? Are we talking about first-timers - or are we talking about getting current participants to do more review?
Yes, this is about recruitment, so focused on first-timers. Reviewers start out as first timers.
Getting current devs to do more review falls on co-maintainer/reviewer rotation to avoid burn-out. I think folks would be more likely to increase their role if they knew it wasn't a full-time commitment until you burn out.
thx,
Jason.
Quoted 13 lines · John W. Linville
Quoted 12 lines · Jason Cooper
Quoted 4 lines · Peter Huewe
Not only the bad people drop out, I've seen quite a lot of good devs vanish for good - and these should be the ones we also should try to keep - especially since I'm not sure whether we can allow such high drop out rates over a long time.
I'd love to hear some specific examples, links to email threads so we can quantify this. I suspect a lot of it is: "I scratched the itch, and didn't have anything else I wanted to add. Then daily life took me away."
Quoted 4 lines
Quoted 1 line
Which is the hard part about qualified people. They're busy. :-)
Hopefully I'm not one of the "bad people", and I don't reallly consider myself a "drop out".
Absolutely not. It was a sad day when I heard you were stepping down.
fwiw, I reached out to someone who I felt was capable to see if he could help. Unfortunately, he had some PhD-thesis thingy going on. :( Back to the 'qualified people are busy' ...
Our greatest mistake is if we don't learn from your experience and make the system better.
Quoted 11 lines
But, I am someone that recently
(i.e. since the last KS) extracted himself from a maintainer role. It seems like I should have something to add here...I was the wireless maintainer for roughly seven years. My situation may be a bit unique in that I was always more of a "Linux guy" than a "wireless guy", and most of the contributors were bigger experts in the technology itself than I ever was. That was fine for a while, but over time that became less and less comfortable for me. I've never really heard anyone else express that sentiment, so this is probably not a widespread concern...
I certainly don't have a lot of the hardware people are submitting patches for, ergo ...
Quoted 9 lines
The bigger concern was that while I was wrangling everyone else's wireless patches, I had less and less time to do useful work elsewhere in the kernel. I definitely have heard other maintainers express similar complaints, so this seems like a relatively common concern. It would be good to find and promote maintainer organizations within subsystems that are less likely to monopolize the mainainer's development time. Previously we have had discussions of how the TIP tree is run, but I'm not sure that works well in every case. Are there other working models for this?
Olof has already mentioned how arm-soc is handled. As a submitter of pull requests to them for years, I can vouch that it works quite well. Additionally, mach-mvebu is co-maintained by myself and three others (there are multiple SoCs in there, we each have our focus).
Since I started a new job (hence less time for kernel work), we've rotated out who takes the lead for each cycle. It's a *huge* relief to know it's not up to me *every* cycle.
Similar experience with Thomas and I on irqchip.
tl;dr: co-maintaining works, works well, and helps avoid burnout. It also opens the door for part-time involvement.
Quoted 5 lines
I guess I'm suggesting the opposite of a "professional maintainer". Some people thrive at being the center of a subsystem, as I did for some time with wireless. But burnout is a problem, and I think we can limit some of that if somehow we can encourage less expansive roles for individual maintainers.
Fully agree.
thx,
Jason.
Quoted 6 lines · John W. Linville
I guess the suggestion becomes a deeper maintainer hierarchy where maintainers only pull from sub-maintainers, and sub-maintainers handle individual patches and smaller pull requests from contributors. This is essentially the model used for wireless. That introduces the problem of increased patch merge latency, for which I have no good suggestions...
We haven't found that to be a problem in mvebu/arm-soc. It does increase the lead time a bit. We stop accepting patches for the coming merge window around -rc5/6 or so. Judicious use of linux-next gives sub-trees good coverage before landing in arm-soc.
I wouldn't advise adding another layer to that tree though. Rather, as I said in my other email, co-maintaining with lead rotation works well.
thx,
Jason.
Quoted 12 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodings
The same people who don't run checkpatch.pl will also not opt in to your QC system.
You should create a procmail filter to processes patches. If the patch fails then it changes the subject from [patch] to [fail] and stores a response (compile warnings etc) in a directory. Then you trigger a macro in mutt and it mails the response.
Or you could just create a generic form letter like Greg does.
regards,
dan carpenter
Quoted 5 lines · On Thu, 9 Jul 2015 12:37:18 -0700 Darren Hart <[email protected]> wrote:
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
Quoted 8 lines
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
Quoted 10 lines
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsLooking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
You mean like a web page that has a bunch of entries (like submitting a paper to a LF conference), and you need to fill out.
Subject:
Fill out a one line top of this patch
Problem or enhancement :
Why did you write this patch? Was there a problem you discovered, or is this a new feature you want to add.
Why this patch is needed:
Why is this patch needed. If you fixed the problem, describe what you did and why you did it this way. If it is a feature, explain why this feature is needed, use cases for this feature, and how to use this new feature. If this adds a new user space interface, make sure you provide a man page (separate)
Patch file to upload:
Captcha: We don't want bots doing this
Then this web server could run get_maintainers.pl and email the appropriate people with a generated formatted patch. It could also allow versioning. Today, people seem to be use to filling out web forms. Obviously, this isn't a requirement to use, but could be used by people that don't already know the Linux process.
It could be a bit smarter than get maintainers, as it could possibly detect typo and whitespace patches and then send it off to the trivial maintainer only.
-- Steve
Quoted 14 lines · Jason Cooper
What we're also looking at here is adjusting the wetware / software boundary. The goal of checkpatch is the same: offload maintainer brain time onto automated software. But it's a double-edged sword. Now we see checkpatch-only patches. Was it a net-gain for maintainer relief? Or simply a shift in the type of annoyances?
I don't know. The lesson learned from checkpatch and other tools shouldn't be lost on any effort we try today. That's not to say we shouldn't try. Rather, we should try new processes and tooling, *and* establish sane goals for the same. "After 1 year of autotest@vger, we'll poll the maintainers and ask if they noticed a difference." This implies some sort of tag system so maintainers can trivially tell when a patch has cleared autotest@vger. Maybe:
Quoted 4 lines
Autotest-passed: https://autotest.kernel.org/2015/07/10/<cookie>
Depending on the proposed system, the goal can be more quantifiable, if needed.
I was going to suggest pretty much the same thing.
Quoted 7 lines
Quoted 7 lines
Josh suggests that we should provide a service that people could push code to and 'get automated feedback on what needs fixing'... but isn't that what checkpatch was for? OK, a local tool can't cross-compile it for you on every platform we support, but it can do a lot of stuff short of that.
Quoted 7 lines
Quoted 2 lines
I do like the idea of a 'test' mailing list which receives patches and checks them for corruption though.
Agree. And in sensible cases, it can suggest a fix. e.g. "Missing S-o-b, please read the DCO [link]. If you agree, add your S-o-b to the end of the commit message. 'git commit -s ...' will add this for you."
I presume this would go back to the list and the submitter. I can see arguments for and against including anyone else on Cc from the original patch. What did you have in mind?
Quoted 8 lines
wrt recruitment, It would be advisable for a few maintainers who are interested to be subscribed to autotest@vger to keep an eye on things and intervene if necessary.
thx,
Jason.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 64 lines · Steven Rostedt
Quoted 5 lines · On Thu, 9 Jul 2015 12:37:18 -0700 Darren Hart <[email protected]> wrote:
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
Quoted 8 lines
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
Quoted 10 lines
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsLooking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
You mean like a web page that has a bunch of entries (like submitting a paper to a LF conference), and you need to fill out.
Subject:
Fill out a one line top of this patch
Problem or enhancement :
Why did you write this patch? Was there a problem you discovered, or is this a new feature you want to add.
Why this patch is needed:
Why is this patch needed. If you fixed the problem, describe what you did and why you did it this way. If it is a feature, explain why this feature is needed, use cases for this feature, and how to use this new feature. If this adds a new user space interface, make sure you provide a man page (separate)
Patch file to upload:
Captcha: We don't want bots doing this
Then this web server could run get_maintainers.pl and email the appropriate people with a generated formatted patch. It could also allow versioning. Today, people seem to be use to filling out web forms. Obviously, this isn't a requirement to use, but could be used by people that don't already know the Linux process.
Quoted 3 lines
It could be a bit smarter than get maintainers, as it could possibly detect typo and whitespace patches and then send it off to the trivial maintainer only.
That's the general idea, yes. For people that need to fix a single thing, or are just getting started, this could be a good sanity checker. It can then use the standard form entry validation processes and return with a bunch of red text indicating errors without even sending the patch to the list.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 14 lines · Dan Carpenter
Quoted 12 lines · Darren Hart
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodings
Quoted 2 lines
The same people who don't run checkpatch.pl will also not opt in to your QC system.
I think they would if it the barrier to use it was lower than LKML. Between our very stringent email formatting requirements and the stigma associated with screwing it up, I think a prominent "Kernel Patch Submitter" web form would be readily used by a lot of first timers.
Once they are used to using that and want to move on to a patch series, we can have instructions on how to do that, which might include a web form which accepts a publicly visible git repository url and branch or tag, along with all the other required cover letter stuff as part of a form.
(See Steve Rostedts response on web forms)
Quoted 7 lines
You should create a procmail filter to processes patches. If the patch fails then it changes the subject from [patch] to [fail] and stores a response (compile warnings etc) in a directory. Then you trigger a macro in mutt and it mails the response.
Or you could just create a generic form letter like Greg does.
OK, so this is precisely the kind of individually developed special purpose wizardry that I think hinders recruitment. Rather than having every maintainer reinvent this wheel in a subtly different a personal way (which gets back to the issues raised about subtly different expectations per maintainer), it makes a lot of sense to me to create a common infrastructure that we can all use.
Thanks,
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 5 lines · On Thu, 9 Jul 2015 14:00:59 -0700 [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 9 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Please don't! I use the 0day bot for testing various patches that I'm experimenting with. These patches are very much not in complete form. When they pass all my tests (and the 0day bot tests), I then start the formal process of turning them into submittable patches.
-- Steve
Quoted 32 lines · Darren Hart
Quoted 14 lines · Jason Cooper
What we're also looking at here is adjusting the wetware / software boundary. The goal of checkpatch is the same: offload maintainer brain time onto automated software. But it's a double-edged sword. Now we see checkpatch-only patches. Was it a net-gain for maintainer relief? Or simply a shift in the type of annoyances?
I don't know. The lesson learned from checkpatch and other tools shouldn't be lost on any effort we try today. That's not to say we shouldn't try. Rather, we should try new processes and tooling, *and* establish sane goals for the same. "After 1 year of autotest@vger, we'll poll the maintainers and ask if they noticed a difference." This implies some sort of tag system so maintainers can trivially tell when a patch has cleared autotest@vger. Maybe:
Quoted 4 lines
Autotest-passed: https://autotest.kernel.org/2015/07/10/<cookie>
Depending on the proposed system, the goal can be more quantifiable, if needed.
I was going to suggest pretty much the same thing.
Quoted 10 lines
Quoted 9 lines
Josh suggests that we should provide a service that people could push code to and 'get automated feedback on what needs fixing'... but isn't that what checkpatch was for? OK, a local tool can't cross-compile it for you on every platform we support, but it can do a lot of stuff short of that.
I do like the idea of a 'test' mailing list which receives patches and checks them for corruption though.
Quoted 8 lines
Quoted 4 lines
Agree. And in sensible cases, it can suggest a fix. e.g. "Missing S-o-b, please read the DCO [link]. If you agree, add your S-o-b to the end of the commit message. 'git commit -s ...' will add this for you."
I presume this would go back to the list and the submitter. I can see arguments for and against including anyone else on Cc from the original patch. What did you have in mind?
List and submitter. That way, receiving parties are all opted-in to the noise.
thx,
Jason.
Quoted 18 lines · Steven Rostedt
Quoted 5 lines · On Thu, 9 Jul 2015 14:00:59 -0700 [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 9 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 4 lines
Please don't! I use the 0day bot for testing various patches that I'm experimenting with. These patches are very much not in complete form. When they pass all my tests (and the 0day bot tests), I then start the formal process of turning them into submittable patches.
To clarify, I wasn't suggesting that 0-day do that in general; I was suggesting that it *might* make sense for an automatic testing bot for potentially malformed submissions to an automated test address might not want to waste time running dozens of builds on something that doesn't meet basic sanity checks.
Along the same lines, there's little point testing if something builds on a dozen architectures if it doesn't even build on x86.
But perhaps the latter filter makes more sense than the former, and it'd be more helpful to give people all the feedback at once, for the same reason GCC doesn't stop at the first error.
- Josh Triplett
Quoted 17 lines · Steven Rostedt
Quoted 5 lines · On Thu, 9 Jul 2015 12:37:18 -0700 Darren Hart <[email protected]> wrote:
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
Quoted 8 lines
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...
Quoted 3 lines
Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
If we could get some of the worst offenders turned *off*, like line length limits, many of its most basic checks are quite useful.
Quoted 43 lines
Quoted 10 lines
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsLooking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
You mean like a web page that has a bunch of entries (like submitting a paper to a LF conference), and you need to fill out.
Subject:
Fill out a one line top of this patch
Problem or enhancement :
Why did you write this patch? Was there a problem you discovered, or is this a new feature you want to add.
Why this patch is needed:
Why is this patch needed. If you fixed the problem, describe what you did and why you did it this way. If it is a feature, explain why this feature is needed, use cases for this feature, and how to use this new feature. If this adds a new user space interface, make sure you provide a man page (separate)
Patch file to upload:
Captcha: We don't want bots doing this
Then this web server could run get_maintainers.pl and email the appropriate people with a generated formatted patch. It could also allow versioning. Today, people seem to be use to filling out web forms. Obviously, this isn't a requirement to use, but could be used by people that don't already know the Linux process.
Quoted 3 lines
It could be a bit smarter than get maintainers, as it could possibly detect typo and whitespace patches and then send it off to the trivial maintainer only.
I think it would make sense for such a bot to be driven by git pushes, rather than solely by a web form. A web form, if any, would just handle automatic submission of a specified git series to the test address.
- Josh Triplett
Quoted 68 lines · Josh Triplett
Quoted 17 lines · Steven Rostedt
Quoted 5 lines · On Thu, 9 Jul 2015 12:37:18 -0700 Darren Hart <[email protected]> wrote:
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
Quoted 8 lines
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...Quoted 3 lines
Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
If we could get some of the worst offenders turned *off*, like line length limits, many of its most basic checks are quite useful.
Quoted 43 lines
Quoted 10 lines
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsLooking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
You mean like a web page that has a bunch of entries (like submitting a paper to a LF conference), and you need to fill out.
Subject:
Fill out a one line top of this patch
Problem or enhancement :
Why did you write this patch? Was there a problem you discovered, or is this a new feature you want to add.
Why this patch is needed:
Why is this patch needed. If you fixed the problem, describe what you did and why you did it this way. If it is a feature, explain why this feature is needed, use cases for this feature, and how to use this new feature. If this adds a new user space interface, make sure you provide a man page (separate)
Patch file to upload:
Captcha: We don't want bots doing this
Then this web server could run get_maintainers.pl and email the appropriate people with a generated formatted patch. It could also allow versioning. Today, people seem to be use to filling out web forms. Obviously, this isn't a requirement to use, but could be used by people that don't already know the Linux process.
Quoted 7 lines
Quoted 3 lines
It could be a bit smarter than get maintainers, as it could possibly detect typo and whitespace patches and then send it off to the trivial maintainer only.
I think it would make sense for such a bot to be driven by git pushes, rather than solely by a web form. A web form, if any, would just handle automatic submission of a specified git series to the test address.
Keep in mind first-timers. They may just have a patch they want to submit. That is where the most value is to be had in automation in my opinion. I agree we should also support a git url and branch, and ultimately more automation on git pushes would be great, but I think that's secondary to the impact on recruitment. However, that may vary by maintainer and where their burden lies from their submitters.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 1 line
I have a dedicated for-review and testing branch which is 0-day monitored and only if I don't hear negative from 0-day stuff moves to my -next branch.
If you ask Fengguang nicely he can mark that branch so the robots will send a successful completion e-mail ... that way you don't have to guess how long to wait for the robots to get around to your branch.
-Tony
From: Steven Rostedt <[email protected]>
Subject: Re: [Ksummit-discuss] [CORE TOPIC] Recruitment (Reviewers, Testers, Maintainers, Hobbyists)
Date: Fri, 10 Jul 2015 11:44:09 -0400
Quoted 27 lines
Quoted 5 lines · On Thu, 9 Jul 2015 12:37:18 -0700 Darren Hart <[email protected]> wrote:
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
Quoted 8 lines
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
Quoted 4 lines
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodings
Quoted 7 lines
Quoted 4 lines
Looking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
You mean like a web page that has a bunch of entries (like submitting a paper to a LF conference), and you need to fill out.
To send patch emails created from git repos on GitHub to the Git mailing list, there is now submitGit:
https://submitgit.herokuapp.com/
https://github.com/rtyley/submitgit
Maybe Roberto, its author (cced), could be convince to do something for the kernel?
Quoted 39 lines · Christian Couder
From: Steven Rostedt <[email protected]>
Subject: Re: [Ksummit-discuss] [CORE TOPIC] Recruitment (Reviewers, Testers, Maintainers, Hobbyists)
Date: Fri, 10 Jul 2015 11:44:09 -0400Quoted 27 lines
Quoted 5 lines · On Thu, 9 Jul 2015 12:37:18 -0700 Darren Hart <[email protected]> wrote:
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
Quoted 8 lines
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
Quoted 4 lines
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsQuoted 7 lines
Quoted 4 lines
Looking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
You mean like a web page that has a bunch of entries (like submitting a paper to a LF conference), and you need to fill out.
Quoted 8 lines
To send patch emails created from git repos on GitHub to the Git mailing list, there is now submitGit:
https://submitgit.herokuapp.com/
https://github.com/rtyley/submitgitMaybe Roberto, its author (cced), could be convince to do something for the kernel?
Something along those lines would be nice, yes. I think a lot of people would find something like this which enforces the "mechanical" rules to be very useful.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 8 lines · Steven Rostedt
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
I'm relatively new to lkml so my perceptions might be skewed. But it seems to me that, for non-trivial patches, the Reviewed-by tag is pretty much useless as a metric. From what I can tell, the biggest problems with relying on Reviewed-by to get meaningful statistics are:
1. It's self-reported by the reviewer.
Maybe a reviewer gave some hugely valuable feedback in versions 1-4 of the patch, but wasn't around to provide the Reviewed-by tag for the final v6.
Or maybe they're just focused on the review, and forget or don't care to ask for credit for it at the time by adding a tag.
Or maybe they're a maintainer who used Signed-off-by instead (but Signed-off-by doesn't necessarily imply a review).
Also, as others have mentioned, it creates the ability to game the system by saying you've reviewed a patch when you really haven't.
2. It's too broad of a statement. It requires the reviewer to make an official certification that they fully understand and approve of the *entire* patch. That's certainly a useful statement, but:
A reviewer might review only part of the patch, and provide some useful comments for just the part of the patch they reviewed. But they don't want to take responsibility for saying, to quote Steven, "I took enough effort to understand every part of the patch as if I wrote it myself."
Or maybe they didn't carefully review the patch, but instead added something valuable to the discussion which improved the patch in a future version.
So it denies credit to all the other people who provided useful comments along the way.
Review comments such as "here's a problem with your code" or "have you thought about doing this instead?" can often be more useful a comment than "your code looks good". Maybe it would be a good idea to acknowledge those people who give valuable feedback, in all its forms. Maybe a new tag would be useful? Something which:
a) is reported by the patch author and/or maintainer, since they're in the best position to keep track of useful comments across versions;
and
b) means something like "I'm grateful to this person for giving some valuable feedback".
Signature · 1 line
Josh
Quoted 37 lines · Theodore Ts'o
Quoted 5 lines · Guenter Roeck
Earlier it was discussed how to improve the recognition of reviewers. Your comments seems to suggest the opposite, and may actually discourage reviewers. Why should I review Linux kernel code if that is seen by some as me trying to "game" the system ?
So I were designing an initial system that automatically scored reviewers, I'd be looking to see, from a holistic point of view, how many reviews were zero-length:
Reviewed-by John Q. Random <[email protected]>... and nothing else,
.... versus how many reviews had specific comments on various different portions of the patch. If possible, the automated system would try to distinguish between comments that were just pointing out whitespace issues (which would be a slight positive) with comments that point out genuine design issues (this will be really hard to do in an automated fashion, but a very sophisticated nueral network[1] mgiht be able to hack it).
I might also try using some kind scheme that counted the number of words in a review (stripping out lines of patch or commit description that the review was a reply to), etc. But of course, if it was public knowledge that the system was just stripping out the original e-mail, and then just doing a "wc -w", then people would game the system by adding list of random words at the bottom of the review.
And, of course, I'd have the system give a huge negative score if a commit that got a "LGTM" positive review caused a bug that required the patch to be reverted. *That* signal, at least, would be hard to game, and would hopefuly encourage people to actually take time reviewing a commit, and not blindly slapping a reviewed-by on a commit they don't understand.
Quoted 6 lines
You see? It's not that reviews in and of themselves are attempts to game the system ---- just so long as they are genuine reviews. If there is evidence that the reviews are issued within seconds of the original patch going out, with a Reviewed-by: line and nothing else, what would *you* think about the quality of that review?
Agreed. On the other side, is gaming really a problem with kernel code reviews ? Sure, a search engine provider will have to look out for abuse patterns, but for code reviews I am not sure if it is worth the effort. I would suspect that it is much more likely that the simple "wc -w" approach should provide you with worthy candidates for the KS. Since you are not dealing with hundreds or thousands of candidates, I'd assume you'll do a hand screening anyway, and quickly identify any gamers. I'd be quite surprised if there are any, though.
Quoted 10 lines
Quoted 4 lines
That may be true for some people, but at the same time I think statements like the above might discourage people who just like cleaning up code for fun. There are several of those working on cleaning up the Linux kernel, and I truly appreciate their efforts.
Sure, but that's not the people who (in my opinion as a program committee member) should be attendingt he Kernel Summit, where we want people who are genuinely clueful about technical and policy issues, and not people like (for example) Nick Krause.
Nick is such an outlier that I really hope he isn't used as a baseline to set any kind of policy. But how do you evaluate someone like, say, Axel Lin, who makes excellent contributions all over the place ?
Thanks,
Guenter
Quoted 3 lines · Jason Cooper
--kernel would go through each patch and auto-fills Cc based on
MAINTAINERS. Amongst a few other things. Shallow threading, check/edit cover letter and so forth.
People blindly CCing everyone get_maintainers finds can be a bit of a problem, either they use --git and the false positive rate is quite high or they don't and they miss out relevant people because MAINTAINERS isn't 100% filled in or the reasons for CCing aren't entirely file based.
The false positives are a bit of an issue since it discourages people doing smaller cleanups over wide areas, you can end up getting CCed on lots of things you touched which can be a bit offputting.
Quoted 8 lines · Guenter Roeck
Agreed. On the other side, is gaming really a problem with kernel code reviews ? Sure, a search engine provider will have to look out for abuse patterns, but for code reviews I am not sure if it is worth the effort. I would suspect that it is much more likely that the simple "wc -w" approach should provide you with worthy candidates for the KS. Since you are not dealing with hundreds or thousands of candidates, I'd assume you'll do a hand screening anyway, and quickly identify any gamers. I'd be quite surprised if there are any, though.
I think the concern is more long term - if we're trying to reward reviewers in order to encourage review then probably now we're fine but if we do it in a way that's gameable will that end up having the effect that we want?
Quoted 44 lines · Guenter Roeck
Quoted 37 lines · Theodore Ts'o
Quoted 5 lines · Guenter Roeck
Earlier it was discussed how to improve the recognition of reviewers. Your comments seems to suggest the opposite, and may actually discourage reviewers. Why should I review Linux kernel code if that is seen by some as me trying to "game" the system ?
So I were designing an initial system that automatically scored reviewers, I'd be looking to see, from a holistic point of view, how many reviews were zero-length:
Reviewed-by John Q. Random <[email protected]>... and nothing else,
.... versus how many reviews had specific comments on various different portions of the patch. If possible, the automated system would try to distinguish between comments that were just pointing out whitespace issues (which would be a slight positive) with comments that point out genuine design issues (this will be really hard to do in an automated fashion, but a very sophisticated nueral network[1] mgiht be able to hack it).
I might also try using some kind scheme that counted the number of words in a review (stripping out lines of patch or commit description that the review was a reply to), etc. But of course, if it was public knowledge that the system was just stripping out the original e-mail, and then just doing a "wc -w", then people would game the system by adding list of random words at the bottom of the review.
And, of course, I'd have the system give a huge negative score if a commit that got a "LGTM" positive review caused a bug that required the patch to be reverted. *That* signal, at least, would be hard to game, and would hopefuly encourage people to actually take time reviewing a commit, and not blindly slapping a reviewed-by on a commit they don't understand.
Quoted 6 lines
You see? It's not that reviews in and of themselves are attempts to game the system ---- just so long as they are genuine reviews. If there is evidence that the reviews are issued within seconds of the original patch going out, with a Reviewed-by: line and nothing else, what would *you* think about the quality of that review?
Quoted 8 lines
Agreed. On the other side, is gaming really a problem with kernel code reviews ? Sure, a search engine provider will have to look out for abuse patterns, but for code reviews I am not sure if it is worth the effort. I would suspect that it is much more likely that the simple "wc -w" approach should provide you with worthy candidates for the KS. Since you are not dealing with hundreds or thousands of candidates, I'd assume you'll do a hand screening anyway, and quickly identify any gamers. I'd be quite surprised if there are any, though.
I've personally seen it, and I don't think I'm alone. It seems to follow a pattern of:
- Manager/HR thinks counting tags is a useful metric (#!@$ laziness).
- tag-count becomes an evaluation item.
- Pay raises are affected.
- patch submitters do the obvious.
- maintainers weep and die a little inside.
The easy ones to spot are multiple-S-o-bs. I've actually been told "No, he didn't write any code, I was just trying to help him out."
The hard ones are when a patch was developed by a company, say a new driver. On the first patch submission, there's a Reviewed-by tag for someone I've never seen on the list. He *could* be the HW engineer that designed the IP block, or he could be the likable guy that got a bad eval last time around. We don't know.
I keep those tags for one simple reason. If a bisect lands on that commit, he'll be in the list of emails for trying to figure out what went wrong. imo, it's better to include him to help diagnose a problem than to play catch-up "Who else remembers this commit?", then Cc/Fwd/Bounce during triage. Which comes back to my "Tags are a responsibility, not a reward."
As has been expressed elsewhere, it also depends on who's doing the patch submitting. There's certainly an element of trust to all of this. Unfamiliar submitters with red flags get asked awkward questions.
thx,
Jason.
Quoted 6 lines · On Fri, 10 Jul 2015 09:34:51 -0700 Josh Triplett <[email protected]> wrote:
Quoted 6 lines
Then this web server could run get_maintainers.pl and email the appropriate people with a generated formatted patch. It could also allow versioning. Today, people seem to be use to filling out web forms. Obviously, this isn't a requirement to use, but could be used by people that don't already know the Linux process.
Quoted 7 lines
Quoted 3 lines
It could be a bit smarter than get maintainers, as it could possibly detect typo and whitespace patches and then send it off to the trivial maintainer only.
I think it would make sense for such a bot to be driven by git pushes, rather than solely by a web form. A web form, if any, would just handle automatic submission of a specified git series to the test address.
But who's doing the git push?
This is about new comers that are submitting their own patch and don't understand the process. If we just point them to a web interface that lets them do a one time shot to submit a fix for something they found, this would eliminate a lot of back and forth that is needed for newbies to get the processing right.
-- Steve
It would be great to turn on submitGit for development of the Linux Kernel. Just to clarify, submitGit is a bridge for sending GitHub pull requests on https://github.com/git/git to [email protected] as correctly formatted emails
I've never submitted a patch to the kernel, but I understand there are many development trees and corresponding maintainers/mailing lists. It would be an interesting task to teach submitGit _where_ a patch should go - and we would need GitHub repos which mirrored the maintainer trees in order for people to open good pull requests against them (I'm assuming it would be wrong for people to just open pull requests against https://github.com/torvalds/linux/).
This script looks interesting:
https://github.com/torvalds/linux/blob/master/scripts/get_maintainer.pl
I'd be interested to hear if anyone would like to try out submitGit for the kernel, and has any further advice.
Roberto
Quoted 56 lines · Darren Hart
Quoted 39 lines · Christian Couder
From: Steven Rostedt <[email protected]>
Subject: Re: [Ksummit-discuss] [CORE TOPIC] Recruitment (Reviewers, Testers, Maintainers, Hobbyists)
Date: Fri, 10 Jul 2015 11:44:09 -0400Quoted 27 lines
Quoted 5 lines · On Thu, 9 Jul 2015 12:37:18 -0700 Darren Hart <[email protected]> wrote:
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
Quoted 8 lines
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
Quoted 4 lines
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsQuoted 7 lines
Quoted 4 lines
Looking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
You mean like a web page that has a bunch of entries (like submitting a paper to a LF conference), and you need to fill out.
Quoted 8 lines
To send patch emails created from git repos on GitHub to the Git mailing list, there is now submitGit:
https://submitgit.herokuapp.com/
https://github.com/rtyley/submitgitMaybe Roberto, its author (cced), could be convince to do something for the kernel?
Something along those lines would be nice, yes. I think a lot of people would find something like this which enforces the "mechanical" rules to be very useful.
--
Darren Hart
Intel Open Source Technology Center
Quoted 2 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart <[email protected]> wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
I still use quilt to send my patch series. Just because I know how it works and I trust it. And I get to see exactly what it is about to send (the only thing it can send is what's in the patches/ directory, nothing else).
I have a script that takes my git tree and creates the patches in a format that quilt will send them nicely.
-- Steve
Quoted 5 lines
spends enough time to make setting that all up worthwhile, but honestly, there are A LOT of ways to embarass yourself with git-send-email. So much so that I've written wrappers to it to protect people from it for the yocto project - and even myself for my kernel work.
Quoted 4 lines · Steven Rostedt
On Thu, 9 Jul 2015 19:07:06 -0700
Darren Hart <[email protected]> wrote:
Quoted 8 lines
Quoted 2 lines
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Perhaps we should provide tools which make it trivial to do the same for various different mail clients, without users having to know where, and in what form, their drafts folders are?
Signature · 1 line
dwmw2
Quoted 4 lines · Steven Rostedt
On Thu, 9 Jul 2015 19:07:06 -0700
Darren Hart <[email protected]> wrote:
Quoted 8 lines
Quoted 2 lines
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
I'm in exactly the same boat. I don't submit patches frequently enough that I trust a git-send-email workflow. It's too automated for me. I'd rather take the extra time to manually format my patch e-mails and my
CC: lists, than be embarrassed. Of course then I make manual mistakes and end up getting embarrassed sometimes anyway, but I can usually avoid a patch embarrassment armageddon.
But my manual steps and self-verification are a lot of work each time, so some automation would be very much appreciated.
Quoted 7 lines
I still use quilt to send my patch series. Just because I know how it works and I trust it. And I get to see exactly what it is about to send (the only thing it can send is what's in the patches/ directory, nothing else).
I have a script that takes my git tree and creates the patches in a format that quilt will send them nicely.
Maybe it would be good for a patch submission tool be able to single-step through the submission preparation, both so that developers can learn from it and not just use it as a crutch, and also to allow developers to intervene if it's about to do something stupid.
-- Tim
Quoted 14 lines · Tim Bird
Quoted 4 lines · Steven Rostedt
On Thu, 9 Jul 2015 19:07:06 -0700
Darren Hart <[email protected]> wrote:Quoted 8 lines
Quoted 2 lines
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Quoted 7 lines
I'm in exactly the same boat. I don't submit patches frequently enough that I trust a git-send-email workflow. It's too automated for me. I'd rather take the extra time to manually format my patch e-mails and my
CC: lists, than be embarrassed. Of course then I make manual mistakes and end up getting embarrassed sometimes anyway, but I can usually avoid a patch embarrassment armageddon.
I use git send-email, but I don't use it blindly. If I use it directly, I give it a trial first with --dry-run. For patch series I use a directory to collect the patches and then use a script to actually send them. Sometimes I also use --cc-cmd with a script I have written to automatically add Cc's, but never without dry-run.
Guenter
Quoted 9 lines · Jason Cooper
Quoted 8 lines
Agreed. On the other side, is gaming really a problem with kernel code reviews ? Sure, a search engine provider will have to look out for abuse patterns, but for code reviews I am not sure if it is worth the effort. I would suspect that it is much more likely that the simple "wc -w" approach should provide you with worthy candidates for the KS. Since you are not dealing with hundreds or thousands of candidates, I'd assume you'll do a hand screening anyway, and quickly identify any gamers. I'd be quite surprised if there are any, though.
Quoted 9 lines
I've personally seen it, and I don't think I'm alone. It seems to follow a pattern of:
- Manager/HR thinks counting tags is a useful metric (#!@$ laziness).
- tag-count becomes an evaluation item.
- Pay raises are affected.
- patch submitters do the obvious.
- maintainers weep and die a little inside.
Sigh :-(. Guess I never had the pleasure of working for any of those companies, and the areas of the kernel I care about may be too obscure to get much attention by the gamers.
Quoted 3 lines
The easy ones to spot are multiple-S-o-bs. I've actually been told "No, he didn't write any code, I was just trying to help him out."
Multiple S-o-b's don't always mean gaming, though. For example, my company's workflow requires me to sign off upstream patches, not to get annother S-o-b with my name on it, but to certify that the patch does not accidentially publish any company IP (and, if it does, it is my fault, not the fault of the person who wrote the code).
Guenter
Quoted 12 lines · Mark Brown
Quoted 3 lines · Jason Cooper
--kernel would go through each patch and auto-fills Cc based on
MAINTAINERS. Amongst a few other things. Shallow threading, check/edit cover letter and so forth.People blindly CCing everyone
get_maintainersfinds can be a bit of a problem, either they use --git and the false positive rate is quite high or they don't and they miss out relevant people becauseMAINTAINERSisn't 100% filled in or the reasons for CCing aren't entirely file based.
Quoted 3 lines
The false positives are a bit of an issue since it discourages people doing smaller cleanups over wide areas, you can end up getting CCed on lots of things you touched which can be a bit offputting.
--git-fallback seems to work pretty well. It nicely embodies the approach of "if it doesn't have a maintainer, talk to the last poor sucker who touched it".
- Josh Triplett
Quoted 9 lines · Steven Rostedt
Quoted 5 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
This is exactly what I do before sending. But I just do:
vim patches/*.patch
That works too. Perhaps that would be the easier option for people who aren't sure of their normal mailer.
It's mostly the *client* that screws formatting up, rather than the transport. So maybe the best thing to advise new people to do is put the messages into files, vet them as you describe above (except using emacs instead of vim, of course), and then provide a simple tool which will *send* the messages from those files, via whatever transport the user needs.
I think we can cope with the SMTP case already but I'm not sure if we can do it from pre-vetted files, or only directly from git-send-email? It's not hard to add support for also sending via ActiveSync and EWS, for the Exchange-afflicted.
Can one still send "from" GMail via SMTP these days? How does the 2 -factor authentication work? Do we cope with that?
Signature · 1 line
dwmw2
Quoted 21 lines · David Woodhouse
Quoted 9 lines · Steven Rostedt
Quoted 5 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
This is exactly what I do before sending. But I just do:
vim patches/*.patch
That works too. Perhaps that would be the easier option for people who aren't sure of their normal mailer.
It's mostly the *client* that screws formatting up, rather than the transport. So maybe the best thing to advise new people to do is put the messages into files, vet them as you describe above (except using emacs instead of vim, of course), and then provide a simple tool which will *send* the messages from those files, via whatever transport the user needs.
Quoted 7 lines
I think we can cope with the SMTP case already but I'm not sure if we can do it from pre-vetted files, or only directly from git-send-email? It's not hard to add support for also sending via ActiveSync and EWS, for the Exchange-afflicted.
Can one still send "from" GMail via SMTP these days? How does the 2 -factor authentication work? Do we cope with that?
You can, but it doesn't support 2FA. You have to generate one of those "device" or "application" passwords and use that instead. Things might have changed since I last set it up, but that is what I had to do to use google SMTP via mutt.
josh
Quoted 10 lines · Steven Rostedt
Quoted 2 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart <[email protected]> wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
I don't use git-send-email either. I use git-format-patch --cover-letter --thread, and then mutt -H to individually send each mail. (I originally added the --thread and --in-reply-to options to git-format-patch, so that you don't need to use git-send-email for that.)
The one thing I *do* find annoying is that the combination of format-patch and get_maintainers.pl can't easily say "I want to send all the patches and the cover letter to the same set of people, based on every patch". (Or, at the very least, the cover letter to everyone.) Otherwise, maintainers get one patch out of the series, which may be confusing without context, and the cover letter doesn't go to anyone. Unfortunately, fixing that then tends to hit LKML's limit on number of recipients.
- Josh Triplett
Quoted 19 lines · David Woodhouse
Quoted 4 lines · Steven Rostedt
On Thu, 9 Jul 2015 19:07:06 -0700
Darren Hart <[email protected]> wrote:Quoted 8 lines
Quoted 2 lines
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
Quoted 4 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Nope, I do that too. (Though then I have to resist the temptation to just fix it in the mailer rather than fixing the original and regenerating.)
Quoted 3 lines
Perhaps we should provide tools which make it trivial to do the same for various different mail clients, without users having to know where, and in what form, their drafts folders are?
git-imap-send does exactly that. The one issue I've observed with
git-imap-send: many mailers, including mutt, will ignore the generated Message-Id, In-Reply-To, and References headers in the drafts, and generate new ones that break threading. That's why I stopped using it and started using mutt -H.
- Josh Triplett
Quoted 11 lines · Jason Cooper
I've personally seen it, and I don't think I'm alone. It seems to follow a pattern of:
- Manager/HR thinks counting tags is a useful metric (#!@$ laziness).
- tag-count becomes an evaluation item.
- Pay raises are affected.
- patch submitters do the obvious.
- maintainers weep and die a little inside.The easy ones to spot are multiple-S-o-bs. I've actually been told "No, he didn't write any code, I was just trying to help him out."
On the flip side, I've submitted patches with two Signed-off-by tags specifically because both people actually wrote the code and are agreeing to the DCO (and more generally claiming responsibility/blame for the patch), and gotten complaints from maintainers that it "doesn't reflect the chain of git trees the patch went through" or similar. Which seems ridiculous.
- Josh Triplett
Quoted 9 lines · On Fri, 2015-07-10 at 13:56 -0700, [email protected] wrote:
Quoted 4 lines · David Woodhouse
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Nope, I do that too. (Though then I have to resist the temptation to just fix it in the mailer rather than fixing the original and regenerating.)
Oh, I *always* just fix it in the mailer, even when the numbers in the hunk headers need to be fixed up :)
Signature · 1 line
dwmw2
Quoted 7 lines · Steven Rostedt
Quoted 5 lines · On Thu, 9 Jul 2015 16:13:52 -0700 [email protected] wrote:
That assumes the patch actually has issues. To use the reviews I do on RCU patches as an example, in a patch series, I might reply to a few patches with "here are some issues; with those fixed, Reviewed-by...", and then reply to the remaining unproblematic patches (individually or in aggregate) with just the Reviewed-by.
Quoted 8 lines
Josh, I read your reviews. Yes, you have a bunch of single "Reviewed-by" tags, but you also have a lot of emails with substantially significant comments. What Ted is saying, is to see how many significant replies one has. In fact, I would say if we were to automate this, each significant reply (one with actual comments), would increase the weight that a single "Reviewed-by" email would carry. That way people like yourself would have more weight attached to emails with single "Reviewed-by" than others that don't have many emails with actual comments attached.
Ah, I see what you're getting at now. I thought you were trying to figure out the value of a "Reviewed-by" on an individual patch. But you're right, a review doesn't carry much weight if your reviews *never* find issues; that would imply you're either chery-picking easy patches to review or rubber-stamping bad patches.
(And conversely, a Reviewed-by on a patch that turns out to be wrong shouldn't carry any more stigma than submitting such a patch yourself. Everybody has submitted a brown-paper-bag at some point; as long as there's not a pattern of it, that's not a critical issue with reviewing.)
- Josh Triplett
Quoted 4 lines · On Fri, 10 Jul 2015 21:00:12 +0100 David Woodhouse <[email protected]> wrote:
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
That's also a good idea. Although I use claws-mail. But it should work.
Quoted 5 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
This is exactly what I do before sending. But I just do:
vim patches/*.patch
Quoted 5 lines
Perhaps we should provide tools which make it trivial to do the same for various different mail clients, without users having to know where, and in what form, their drafts folders are?
Sounds like a plan ;-)
-- Steve
Quoted 7 lines · David Woodhouse
Quoted 6 lines · On Fri, 2015-07-10 at 13:56 -0700, [email protected] wrote:
Quoted 4 lines · David Woodhouse
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Quoted 6 lines
Quoted 3 lines
Nope, I do that too. (Though then I have to resist the temptation to just fix it in the mailer rather than fixing the original and regenerating.)
Oh, I *always* just fix it in the mailer, even when the numbers in the hunk headers need to be fixed up :)
I've occasionally fixed up actual typos in the patch content, though never changing the number of lines. The danger there is what happens when you need to prepare v(N+1). If you're going to need to change it in git anyway, you might as well go ahead and do so and regenerate the series.
I just wish I had a more satisfactory method of associating a cover letter with a series *in git*, such that format-patch could emit a non-placeholder cover letter.
- Josh Triplett
Quoted 7 lines · On Thu, 9 Jul 2015 12:44:56 -0700 Darren Hart <[email protected]> wrote:
Agreed. I have this same conversation about commit messages. I don't care if it's a whitespace fix, if it is worth patching, building, testing, and submitting, it is worth writing a sentence about why you did it and what it's for. The same applies to a review. What did you confirm? Did you build it? Run checkpatch or some other static analysis? I think I'm also guilty of a one-line review now and then, but I'll be sure to include detail in the future.
Very good point.
Again, not talking about regular people that a maintainer knows well. But a Reviewed-by tag could at least also add what the reviewer did to add it. "I examined the entire patch, and found nothing wrong with it", is an acceptable comment. So is, "I looked at the patch and even built and booted it. Looks good".
Again, I have a few people I ask to review patches, and just them replying with "Reviewed-by" is good enough for me. Because I know them well and know what they usually do when they do a review. I don't need them to be constantly telling me what they did.
-- Steve
Quoted 23 lines · Guenter
Quoted 9 lines · Jason Cooper
Quoted 8 lines
Agreed. On the other side, is gaming really a problem with kernel code reviews ? Sure, a search engine provider will have to look out for abuse patterns, but for code reviews I am not sure if it is worth the effort. I would suspect that it is much more likely that the simple "wc -w" approach should provide you with worthy candidates for the KS. Since you are not dealing with hundreds or thousands of candidates, I'd assume you'll do a hand screening anyway, and quickly identify any gamers. I'd be quite surprised if there are any, though.
Quoted 9 lines
I've personally seen it, and I don't think I'm alone. It seems to follow a pattern of:
- Manager/HR thinks counting tags is a useful metric (#!@$ laziness).
- tag-count becomes an evaluation item.
- Pay raises are affected.
- patch submitters do the obvious.
- maintainers weep and die a little inside.Sigh :-(. Guess I never had the pleasure of working for any of those companies, and the areas of the kernel I care about may be too obscure to get much attention by the gamers.
Quoted 8 lines
Quoted 3 lines
The easy ones to spot are multiple-S-o-bs. I've actually been told "No, he didn't write any code, I was just trying to help him out."
Multiple S-o-b's don't always mean gaming, though. For example, my company's workflow requires me to sign off upstream patches, not to get annother S-o-b with my name on it, but to certify that the patch does not accidentially publish any company IP (and, if it does, it is my fault, not the fault of the person who wrote the code).
There is a danger to having people interpret the s-o-b tag differently than what it originally was intended for, such confusion deserves serious attention and my hope is that if folks detect these misuses they can try to educate folks on it. The s-o-b tag means the person is certifying under the Developer Certificate or Origin (DCO) the patch in question. That's it. The practical gains of such a leight weight development tool to use something like the s-o-b combined with the huge legal merit behind it has convinced us to generalize the DCO and encourage people outside of Linux to use it:
http://developercertificate.org/
There was coverage over this on lwn:
https://lwn.net/Articles/592503/
I've also written about the importance here:
http://www.do-not-panic.com/2014/02/developer-certificate-of-origin.html
The list of users is outdated and I cannot keep up counting folks using it, but the more, quite recently the docker project announced it was embracing it for instance (although it seems they modified it mildly, WTF(?)):
https://blog.docker.com/2014/01/docker-code-contributions-require-developer-certificate-of-origin/
Because of its legal value, and because we all stand to gain from this legal value then as a commnity at large we should try to correc innappropriate uses of the s-o-b and educate folks on it.
I'll stay out of the conversation of other tag's, only to second Julia's sentiments
Luis
Quoted 6 lines · On Thu, 9 Jul 2015 16:13:52 -0700 [email protected] wrote:
That assumes the patch actually has issues. To use the reviews I do on RCU patches as an example, in a patch series, I might reply to a few patches with "here are some issues; with those fixed, Reviewed-by...", and then reply to the remaining unproblematic patches (individually or in aggregate) with just the Reviewed-by.
Josh, I read your reviews. Yes, you have a bunch of single "Reviewed-by" tags, but you also have a lot of emails with substantially significant comments. What Ted is saying, is to see how many significant replies one has. In fact, I would say if we were to automate this, each significant reply (one with actual comments), would increase the weight that a single "Reviewed-by" email would carry. That way people like yourself would have more weight attached to emails with single "Reviewed-by" than others that don't have many emails with actual comments attached.
Anyway, for consideration to KS, the top reviewers that an automated system would produce, would only get the program committee's eyes looking at it. It by no way guarantees an invite. No matter what automated system is in place, at least for KS, there will always be humans involved in analyzing that data.
-- Steve
On Fri, Jul 10, 2015 at 08:35:59PM +0100, Roberto Tyley wrote:
Hi Roberto,
Thanks for chiming in.
Quoted 4 lines
It would be great to turn on submitGit for development of the Linux Kernel. Just to clarify, submitGit is a bridge for sending GitHub pull requests on https://github.com/git/git to [email protected] as correctly formatted emails
While there is value there and would help a lot of people, given the popularity of git-hub, I think we're looking for something more generic.
I'd prefer a web-form hosted on kernel.org that could accept a raw patch, or a git URL and tag or branch from any reposiory (github or otherwise), and submit the patch after performing a number of validation checks before ever sending to the list.
I understand this maybe isn't an extension of submitGit, but the concept of submitGit is interesting from a precedence perspective.
Quoted 10 lines
I've never submitted a patch to the kernel, but I understand there are many development trees and corresponding maintainers/mailing lists. It would be an interesting task to teach submitGit _where_ a patch should go - and we would need GitHub repos which mirrored the maintainer trees in order for people to open good pull requests against them (I'm assuming it would be wrong for people to just open pull requests against https://github.com/torvalds/linux/).
This script looks interesting:
https://github.com/torvalds/linux/blob/master/scripts/get_maintainer.pl
Yes, this should be used to identify lists and maintainers who should be Cc'd.
Quoted 5 lines
I'd be interested to hear if anyone would like to try out submitGit for the kernel, and has any further advice.
Roberto
Thanks,
Darren
P.S. I don't know if your top posting was intentional (very clever) or accidental (case in point), but either way it's dripping with irony. ;-)
Quoted 60 lines · Darren Hart
Quoted 56 lines · Christian Couder
Quoted 39 lines
From: Steven Rostedt <[email protected]>
Subject: Re: [Ksummit-discuss] [CORE TOPIC] Recruitment (Reviewers, Testers, Maintainers, Hobbyists)
Date: Fri, 10 Jul 2015 11:44:09 -0400Quoted 27 lines
Quoted 5 lines · On Thu, 9 Jul 2015 12:37:18 -0700 Darren Hart <[email protected]> wrote:
I've come to believe that this is one of many side effects of our dependency on a completely free form mechanism for the management of our patches, a mechanism which is becoming harder and harder to setup "correctly" with modern tooling (since the industry is killing "real email").
Quoted 8 lines
I spend a highly disproportionate amount of my time, relative to measurable quality impact to the kernel, going over the nuances of submitting patches.
1) Must have a complete commit message
2) DCO goes above the ---
3) Include a patch changelog, do so below ---
4) Cc maintainers :-)
5) Checkpatch... checkpatch... checkpatch...Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
Quoted 4 lines
6) Compiler warnings
7) CodingStyle :-)
8) Use ascii or utf8 character encodingsQuoted 7 lines
Quoted 4 lines
Looking forward a bit, I would love to see some tooling in place for people to submit patches either via a web form (which eliminates all the email tooling for submitting patches - which is where the formatting is especially critical) or through one of the more managed git systems, like gerrit, etc.
You mean like a web page that has a bunch of entries (like submitting a paper to a LF conference), and you need to fill out.
Quoted 8 lines
To send patch emails created from git repos on GitHub to the Git mailing list, there is now submitGit:
https://submitgit.herokuapp.com/
https://github.com/rtyley/submitgitMaybe Roberto, its author (cced), could be convince to do something for the kernel?
Something along those lines would be nice, yes. I think a lot of people would find something like this which enforces the "mechanical" rules to be very useful.
--
Darren Hart
Intel Open Source Technology Center
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 18 lines · Josh Triplett
Quoted 10 lines · Steven Rostedt
Quoted 2 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart <[email protected]> wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
I don't use git-send-email either. I use git-format-patch --cover-letter --thread, and then mutt -H to individually send each mail. (I originally added the --thread and --in-reply-to options to git-format-patch, so that you don't need to use git-send-email for that.)
Quoted 4 lines
The one thing I *do* find annoying is that the combination of format-patch and get_maintainers.pl can't easily say "I want to send all the patches and the cover letter to the same set of people, based on every patch". (Or, at the very least, the cover letter to everyone.)
A bit off topic, but:
+1000 (thanks for that Steven)
This is partly why I wrote create-pull-request and submit-pull-request for the Yocto Project.
http://git.yoctoproject.org/cgit/cgit.cgi/poky/tree/scripts/create-pull-request
http://git.yoctoproject.org/cgit/cgit.cgi/poky/tree/scripts/send-pull-request
They build the recipient list for each patch and the aggregate for the cover letter, set confirm always, and disable git-send-email CC policy to avoid spamming the planet.
Quoted 7 lines
Otherwise, maintainers get one patch out of the series, which may be confusing without context, and the cover letter doesn't go to anyone. Unfortunately, fixing that then tends to hit LKML's limit on number of recipients.
- Josh Triplett
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 19 lines · David Woodhouse
Quoted 4 lines · Steven Rostedt
On Thu, 9 Jul 2015 19:07:06 -0700
Darren Hart <[email protected]> wrote:Quoted 8 lines
Quoted 2 lines
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
Quoted 4 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
I thought it was just me :)
I use git format-patch for this same purpose.
Quoted 5 lines
Perhaps we should provide tools which make it trivial to do the same for various different mail clients, without users having to know where, and in what form, their drafts folders are?
An update to the documentation on mail clients would be welcome - although it's looking pretty bleak out there for usable mail clients these days.
The fact that we're having this discussion among the folks that ostensibly know what we're doing is very telling, in my opinion, of just how daunting a task this can be for a new-comer.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 21 lines · David Woodhouse
Quoted 9 lines · Steven Rostedt
Quoted 5 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
This is exactly what I do before sending. But I just do:
vim patches/*.patch
That works too. Perhaps that would be the easier option for people who aren't sure of their normal mailer.
It's mostly the *client* that screws formatting up, rather than the transport. So maybe the best thing to advise new people to do is put the messages into files, vet them as you describe above (except using emacs instead of vim, of course), and then provide a simple tool which will *send* the messages from those files, via whatever transport the user needs.
Quoted 7 lines
I think we can cope with the SMTP case already but I'm not sure if we can do it from pre-vetted files, or only directly from git-send-email? It's not hard to add support for also sending via ActiveSync and EWS, for the Exchange-afflicted.
Can one still send "from" GMail via SMTP these days? How does the 2 -factor authentication work? Do we cope with that?
This simple tool should not run on the client IMO. Or should be *required* to run on the client. The kernel.org patch submission web form would be usable by anyone with a browser ... OK, go ahead... "anyone with a browser" is too low a bar for a kernel developer.... :-)
But seriously, we're talking about recruitment, and this is the kind of tooling I routinely here non-Linux developers shake their heads at when considering our development process. So while you and I are fine using vi (*jab*) and mutt (*evolution) and arcane bash (*posix shell*) scripts and local MTAs... others would very much like to focus on the code they are changing, and let the computers handle schlepping the changesets around. Especially when they only have a couple of patches to send, the setup is significant barrier.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 21 lines · Josh Triplett
Quoted 7 lines · David Woodhouse
Quoted 6 lines · On Fri, 2015-07-10 at 13:56 -0700, [email protected] wrote:
Quoted 4 lines · David Woodhouse
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Quoted 6 lines
Quoted 3 lines
Nope, I do that too. (Though then I have to resist the temptation to just fix it in the mailer rather than fixing the original and regenerating.)
Oh, I *always* just fix it in the mailer, even when the numbers in the hunk headers need to be fixed up :)
I've occasionally fixed up actual typos in the patch content, though never changing the number of lines. The danger there is what happens when you need to prepare v(N+1). If you're going to need to change it in git anyway, you might as well go ahead and do so and regenerate the series.
Quoted 3 lines
I just wish I had a more satisfactory method of associating a cover letter with a series *in git*, such that format-patch could emit a non-placeholder cover letter.
I use my tags for a similar purpose, combined with a git-pdx-pull-request.sh script which generates the cover letter. And now that I bisected the missing header, vger will actually deliver it to the list! \o/
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 9 lines · Darren Hart
Quoted 2 lines · Dan Carpenter
Or you could just create a generic form letter like Greg does.
OK, so this is precisely the kind of individually developed special purpose wizardry that I think hinders recruitment. Rather than having every maintainer reinvent this wheel in a subtly different a personal way (which gets back to the issues raised about subtly different expectations per maintainer), it makes a lot of sense to me to create a common infrastructure that we can all use.
Ok, feel free to use my "form letter" that I've created over the years and expand on it for more common problems if I've missed anything. I just dump it into a response to the patch (3 keystrokes), and cut away anything that isn't relevant to this specific patch. Seems to work pretty well in cutting down on me having to type the same thing all the time.
--------------------------
Hi,
This is the friendly patch-bot of Greg Kroah-Hartman. You have sent him a patch that has triggered this response. He used to manually respond to these common problems, but in order to save his sanity (he kept writing the same thing over and over, yet to different people), I was created. Hopefully you will not take offence and will fix the problem in your patch and resubmit it so that it can be accepted into the Linux kernel tree.
You are receiving this message because of the following common error(s) as indicated below:
- Your patch breaks the build.
- Your patch contains warnings and/or errors noticed by the scripts/checkpatch.pl tool.
- Your patch is malformed (tabs converted to spaces, linewrapped, etc.) and can not be applied. Please read the file, Documentation/email-clients.txt in order to fix this.
- Your patch does not have a Signed-off-by: line. Please read the kernel file, Documentation/SubmittingPatches and resend it after adding that line. Note, the line needs to be in the body of the email, before the patch, not at the bottom of the patch or in the email signature.
- Your patch was sent privately to Greg. Kernel development is done in public, please always cc: a public mailing list with a patch submission. Using the tool, scripts/get_maintainer.pl on the patch will tell you what mailing list to cc.
- Your patch did many different things all at once, making it difficult to review. All Linux kernel patches need to only do one thing at a time. If you need to do multiple things (such as clean up all coding style issues in a file/driver), do it in a sequence of patches, each one doing only one thing. This will make it easier to review the patches to ensure that they are correct, and to help alleviate any merge issues that larger patches can cause.
- Your patch did not apply to any known trees that Greg is in control of. Possibly this is because you made it against Linus's tree, not the linux-next tree, which is where all of the development for the next version of the kernel is at. Please refresh your patch against the linux-next tree, or even better yet, the development tree specified in the MAINTAINERS file for the subsystem you are submitting a patch for, and resend it.
- You sent multiple patches, yet no indication of which ones should be applied in which order. Greg could just guess, but if you are receiving this email, he guessed wrong and the patches didn't apply. Please read the section entitled "The canonical patch format" in the kernel file, Documentation/SubmittingPatches for a description of how to do this so that Greg has a chance to apply these correctly.
- You did not specify a description of why the patch is needed, or possibly, any description at all, in the email body. Please read the section entitled "The canonical patch format" in the kernel file, Documentation/SubmittingPatches for what is needed in order to properly describe the change.
- You did not write a descriptive Subject: for the patch, allowing Greg, and everyone else, to know what this patch is all about. Please read the section entitled "The canonical patch format" in the kernel file, Documentation/SubmittingPatches for what a proper Subject: line should look like.
If you wish to discuss this problem further, or you have questions about how to resolve this issue, please feel free to respond to this email and Greg will reply once he has dug out from the pending patches received from other developers.
thanks,
greg k-h's patch email bot
Quoted 11 lines · Darren Hart
On Fri, Jul 10, 2015 at 08:35:59PM +0100, Roberto Tyley wrote:
Hi Roberto,
Thanks for chiming in.
Quoted 4 lines
It would be great to turn on submitGit for development of the Linux Kernel. Just to clarify, submitGit is a bridge for sending GitHub pull requests on https://github.com/git/git to [email protected] as correctly formatted emails
Quoted 8 lines
While there is value there and would help a lot of people, given the popularity of git-hub, I think we're looking for something more generic.
I'd prefer a web-form hosted on kernel.org that could accept a raw patch, or a git URL and tag or branch from any reposiory (github or otherwise), and submit the patch after performing a number of validation checks before ever sending to the list.
FWIW, an upload system has existed for a while for ARM Linux for final submissions. Note this is distinctly not for review so correctly e-mailing a patch is still necessary. I still find the web form useful though for making submissions.
http://www.arm.linux.org.uk/developer/patches/info.php
Thanks,
Laura
Quoted 5 lines · Darren Hart
This simple tool should not run on the client IMO. Or should be *required* to run on the client. The kernel.org patch submission web form would be usable by anyone with a browser ... OK, go ahead... "anyone with a browser" is too low a bar for a kernel developer.... :-)
Quoted 7 lines
But seriously, we're talking about recruitment, and this is the kind of tooling I routinely here non-Linux developers shake their heads at when considering our development process. So while you and I are fine using vi (*jab*) and mutt (*evolution) and arcane bash (*posix shell*) scripts and local MTAs... others would very much like to focus on the code they are changing, and let the computers handle schlepping the changesets around. Especially when they only have a couple of patches to send, the setup is significant barrier.
Can you really do kernel development without touching a command line?
Perhaps we need a graphical tool based on gitk in which you can select a set of commits, edit a cover letter and (initially autogenerated) set of recipients, and then it'll send them for you?
Signature · 1 line
dwmw2
Quoted 14 lines · David Woodhouse
Quoted 5 lines · Darren Hart
This simple tool should not run on the client IMO. Or should be *required* to run on the client. The kernel.org patch submission web form would be usable by anyone with a browser ... OK, go ahead... "anyone with a browser" is too low a bar for a kernel developer.... :-)
Quoted 7 lines
But seriously, we're talking about recruitment, and this is the kind of tooling I routinely here non-Linux developers shake their heads at when considering our development process. So while you and I are fine using vi (*jab*) and mutt (*evolution) and arcane bash (*posix shell*) scripts and local MTAs... others would very much like to focus on the code they are changing, and let the computers handle schlepping the changesets around. Especially when they only have a couple of patches to send, the setup is significant barrier.
Quoted 1 line
Can you really do kernel development without touching a command line?
Of course not :-) But that's not the same thing as having to setup up a lot of very custom special purpose tooling that you don't need for anything else just to share a patch.
Quoted 4 lines
Perhaps we need a graphical tool based on gitk in which you can select a set of commits, edit a cover letter and (initially autogenerated) set of recipients, and then it'll send them for you?
That's not a bad idea, basic git usage is a requirement for kernel development. It still depends on a successful gitk client installation, a local SMTP configuration, possible firewall setup, etc. And I confess to be selfish in this regard, I'm tired of helping people set that all up! That's why I like the web submission form. Web connectivity is ubiquitous, no additonal setup is required beyond an initial email verification through the same web service. A lot of people outside the core developers do development through ssh to a managed Linux machine, and are not running a Linux Desktop environment.
After some successful submissions through this, people will migrate to something more advanced if they are to continue with kernel development, and something like gitk integration isn't a bad idea as it can easily be preconfigured to do all the right things with email mechanics that are becoming increasingly difficult to configure modern GUI clients for (and most people are using a modern GUI client for everything except Linux development these days).
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 18 lines · On Fri, Jul 10, 2015 at 1:54 PM, <[email protected]> wrote:
Quoted 10 lines · Steven Rostedt
Quoted 2 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart <[email protected]> wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
I don't use git-send-email either. I use git-format-patch --cover-letter --thread, and then mutt -H to individually send each mail. (I originally added the --thread and --in-reply-to options to git-format-patch, so that you don't need to use git-send-email for that.)
Quoted 9 lines
The one thing I *do* find annoying is that the combination of format-patch and get_maintainers.pl can't easily say "I want to send all the patches and the cover letter to the same set of people, based on every patch". (Or, at the very least, the cover letter to everyone.) Otherwise, maintainers get one patch out of the series, which may be confusing without context, and the cover letter doesn't go to anyone. Unfortunately, fixing that then tends to hit LKML's limit on number of recipients.
I carry this patch on top of StGit for exactly this purpose.
commit 562aca51a303e841a76defc3148db5c69b688994
Author: Dan Williams <[email protected]> Date: Thu Feb 27 11:54:32 2014 -0800
mail: auto cc cover letter to union of all attribution tags in a series
If a receiver is only copied on the a single patch out of a larger
series she
may not have the necessary context to judge the patch. Auto cc her on the cover letter.
stgit/commands/mail.py +11 -1
@@ -534,8 +534,18 @@ def __build_cover(tmpl, msg_id, options, patches): except Exception, ex: raise CmdException, 'template parsing error: %s' % str(ex) + extra_cc = [] + if options.auto: + for patch in patches: + p = crt_series.get_patch(patch) + if p.get_description(): + descr = p.get_description().strip() + extra_cc.extend(__get_signers_list(descr)) + extra_cc = list(set(extra_cc)) + + if not options.git: - __build_address_headers(msg, options) + __build_address_headers(msg, options, extra_cc) __build_extra_headers(msg, msg_id, options.in_reply_to) __encode_message(msg)
Quoted 11 lines · Greg KH
Quoted 9 lines · Darren Hart
Quoted 2 lines · Dan Carpenter
Or you could just create a generic form letter like Greg does.
OK, so this is precisely the kind of individually developed special purpose wizardry that I think hinders recruitment. Rather than having every maintainer reinvent this wheel in a subtly different a personal way (which gets back to the issues raised about subtly different expectations per maintainer), it makes a lot of sense to me to create a common infrastructure that we can all use.
Quoted 6 lines
Ok, feel free to use my "form letter" that I've created over the years and expand on it for more common problems if I've missed anything. I just dump it into a response to the patch (3 keystrokes), and cut away anything that isn't relevant to this specific patch. Seems to work pretty well in cutting down on me having to type the same thing all the time.
Do you have something that automates the scanning for basic errors and builds and reports to you - or do you manually pull every patch out of your email client and run those tests yourself to find that the patch-bot needs to be deployed? That's the kind of thing that it seems like could be automated and improve the quality level of patches that make it to the maintainers.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Hi Luis,
Quoted 7 lines · Luis R. Rodriguez
Quoted 6 lines
Quoted 1 line
Multiple S-o-b's don't always mean gaming, though. For example, my company's workflow requires me to sign off upstream patches, not to get annother S-o-b with my name on it, but to certify that the patch does not accidentially publish any company IP (and, if it does, it is my fault, not the fault of the person who wrote the code).
Quoted 10 lines
There is a danger to having people interpret the s-o-b tag differently than what it originally was intended for, such confusion deserves serious attention and my hope is that if folks detect these misuses they can try to educate folks on it. The s-o-b tag means the person is certifying under the Developer Certificate or Origin (DCO) the patch in question. That's it. The practical gains of such a leight weight development tool to use something like the s-o-b combined with the huge legal merit behind it has convinced us to generalize the DCO and encourage people outside of Linux to use it:
Not really sure if I understand you correctly. Are you saying that you consider the above to be a mis-use of s-o-b ?
By co-signing a patch I do (co-)certify it under DCO; I am well aware of that. That it may have an additional context doesn't change that, or limit its value. I can well imagine that other companies have a similar approval flow, and I don't really understand why that would or could be a problem. Can you educate me ?
Thanks,
Guenter
Quoted 15 lines · Josh Poimboeuf
Quoted 8 lines · Steven Rostedt
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
I'm relatively new to lkml so my perceptions might be skewed. But it seems to me that, for non-trivial patches, the Reviewed-by tag is pretty much useless as a metric. From what I can tell, the biggest problems with relying on Reviewed-by to get meaningful statistics are:
Quoted 5 lines
1. It's self-reported by the reviewer.
Maybe a reviewer gave some hugely valuable feedback in versions 1-4 of the patch, but wasn't around to provide the Reviewed-by tag for the final v6.
Normally good maintainers pick up ack/review tags along the way when they pickup the final patch.
Quoted 6 lines
Or maybe they're just focused on the review, and forget or don't care to ask for credit for it at the time by adding a tag.
Or maybe they're a maintainer who used Signed-off-by instead (but Signed-off-by doesn't necessarily imply a review).
At least at some level any patches picked up by a maintainer should at least be compile tested and looked at any obvious issues -- when the maintainer trusts other devs/submaintainers that did the more thorough review process.
Quoted 3 lines
Also, as others have mentioned, it creates the ability to game the system by saying you've reviewed a patch when you really haven't.
The system can always be gamed.
Quoted 11 lines
2. It's too broad of a statement. It requires the reviewer to make an official certification that they fully understand and approve of the *entire* patch. That's certainly a useful statement, but:
A reviewer might review only part of the patch, and provide some useful comments for just the part of the patch they reviewed. But they don't want to take responsibility for saying, to quote Steven, "I took enough effort to understand every part of the patch as if I wrote it myself."
Quoted 6 lines
Or maybe they didn't carefully review the patch, but instead added something valuable to the discussion which improved the patch in a future version.
So it denies credit to all the other people who provided useful comments along the way.
Mentioning/thanking others that helped in any meaningful way is always a good idea.
Quoted 7 lines
Review comments such as "here's a problem with your code" or "have you thought about doing this instead?" can often be more useful a comment than "your code looks good". Maybe it would be a good idea to acknowledge those people who give valuable feedback, in all its forms. Maybe a new tag would be useful? Something which:
Quoted 7 lines
a) is reported by the patch author and/or maintainer, since they're in the best position to keep track of useful comments across versions;
and
b) means something like "I'm grateful to this person for giving some valuable feedback".
A tag for this? Nah.
Thanks,
Davidlohr
Quoted 19 lines · Guenter
Quoted 9 lines · Jason Cooper
Quoted 8 lines
Agreed. On the other side, is gaming really a problem with kernel code reviews ? Sure, a search engine provider will have to look out for abuse patterns, but for code reviews I am not sure if it is worth the effort. I would suspect that it is much more likely that the simple "wc -w" approach should provide you with worthy candidates for the KS. Since you are not dealing with hundreds or thousands of candidates, I'd assume you'll do a hand screening anyway, and quickly identify any gamers. I'd be quite surprised if there are any, though.
Quoted 9 lines
I've personally seen it, and I don't think I'm alone. It seems to follow a pattern of:
- Manager/HR thinks counting tags is a useful metric (#!@$ laziness).
- tag-count becomes an evaluation item.
- Pay raises are affected.
- patch submitters do the obvious.
- maintainers weep and die a little inside.
Quoted 8 lines
Sigh :-(. Guess I never had the pleasure of working for any of those companies, and the areas of the kernel I care about may be too obscure to get much attention by the gamers.
Quoted 3 lines
The easy ones to spot are multiple-S-o-bs. I've actually been told "No, he didn't write any code, I was just trying to help him out."
Multiple S-o-b's don't always mean gaming, though.
Agreed, if two people edited a patch, or there's one person approved to cleanup/email LKML, etc. Then multiple-SoB makes sense wrt DCO. My wording could have been better. I had a specific incident in mind, but that doesn't make a rule.
thx,
Jason.
Quoted 10 lines · On Fri, Jul 10, 2015 at 02:00:40PM -0700, [email protected] wrote:
Quoted 9 lines · Jason Cooper
I've personally seen it, and I don't think I'm alone. It seems to follow a pattern of:
- Manager/HR thinks counting tags is a useful metric (#!@$ laziness).
- tag-count becomes an evaluation item.
- Pay raises are affected.
- patch submitters do the obvious.
- maintainers weep and die a little inside.
Quoted 7 lines
Quoted 2 lines
The easy ones to spot are multiple-S-o-bs. I've actually been told "No, he didn't write any code, I was just trying to help him out."
On the flip side, I've submitted patches with two Signed-off-by tags specifically because both people actually wrote the code and are agreeing to the DCO (and more generally claiming responsibility/blame for the patch),
This seems perfectly sane to me.
Quoted 3 lines
and gotten complaints from maintainers that it "doesn't reflect the chain of git trees the patch went through" or similar. Which seems ridiculous.
Agreed.
thx,
Jason.
Quoted 19 lines · Darren Hart
Quoted 11 lines · Greg KH
Quoted 9 lines · Darren Hart
Quoted 2 lines · Dan Carpenter
Or you could just create a generic form letter like Greg does.
OK, so this is precisely the kind of individually developed special purpose wizardry that I think hinders recruitment. Rather than having every maintainer reinvent this wheel in a subtly different a personal way (which gets back to the issues raised about subtly different expectations per maintainer), it makes a lot of sense to me to create a common infrastructure that we can all use.
Quoted 6 lines
Ok, feel free to use my "form letter" that I've created over the years and expand on it for more common problems if I've missed anything. I just dump it into a response to the patch (3 keystrokes), and cut away anything that isn't relevant to this specific patch. Seems to work pretty well in cutting down on me having to type the same thing all the time.
Quoted 4 lines
Do you have something that automates the scanning for basic errors and builds and reports to you - or do you manually pull every patch out of your email client and run those tests yourself to find that the patch-bot needs to be deployed?
Almost all of the issues I list in that response I find just by looking at the patch, they jump out instantly. The ones for when the build is broken or the patch doesn't apply get found when I do my "apply this mbox of patches" work, which I usually do in chunks of 5 patches at a time.
So no, I don't have anything automated, so yes almost all of these could be found by a tool. Oh look, we have that tool, which no one uses, checkpatch.pl.
Ok, checkpatch will not catch the issue where your email client is messed up, or when you send a series of patches with no numbering on them, but that's way down the list of errors that I see by quantity. And I think I review more "first timer" patches than anyone else in the community. If people actually ran checkpatch it would resolve almost all of the issues I see.
Quoted 2 lines
That's the kind of thing that it seems like could be automated and improve the quality level of patches that make it to the maintainers.
All of these are the "simple" issues that really don't take long to resolve. We have it documented in great detail on how to set up an email client, how to format the patch, and how to get everything right on the kernelnewbies.org site. I also teach a class on this, one hour max is all it takes, unless you are at a company with a broken email system. And then all bets are off, you better just install a Linux email server in the corner to resolve your email issues, just like all the major companies did (IBM, Intel, Microsoft, etc.)
I applaud your attempt here, and don't want to stop you from working on it, but I think the real issue is having people actually look for the documentation and tools we already have created to do this. If you make yet-another-tool, how are you going to advertise it any better than the existing tools/documentation are?
good luck,
greg k-h
Quoted 45 lines · Greg KH
Quoted 19 lines · Darren Hart
Quoted 11 lines · Greg KH
Quoted 9 lines · Darren Hart
Quoted 2 lines · Dan Carpenter
Or you could just create a generic form letter like Greg does.
OK, so this is precisely the kind of individually developed special purpose wizardry that I think hinders recruitment. Rather than having every maintainer reinvent this wheel in a subtly different a personal way (which gets back to the issues raised about subtly different expectations per maintainer), it makes a lot of sense to me to create a common infrastructure that we can all use.
Quoted 6 lines
Ok, feel free to use my "form letter" that I've created over the years and expand on it for more common problems if I've missed anything. I just dump it into a response to the patch (3 keystrokes), and cut away anything that isn't relevant to this specific patch. Seems to work pretty well in cutting down on me having to type the same thing all the time.
Quoted 4 lines
Do you have something that automates the scanning for basic errors and builds and reports to you - or do you manually pull every patch out of your email client and run those tests yourself to find that the patch-bot needs to be deployed?
Almost all of the issues I list in that response I find just by looking at the patch, they jump out instantly. The ones for when the build is broken or the patch doesn't apply get found when I do my "apply this mbox of patches" work, which I usually do in chunks of 5 patches at a time.
So no, I don't have anything automated, so yes almost all of these could be found by a tool. Oh look, we have that tool, which no one uses, checkpatch.pl.
Ok, checkpatch will not catch the issue where your email client is messed up, or when you send a series of patches with no numbering on them, but that's way down the list of errors that I see by quantity. And I think I review more "first timer" patches than anyone else in the community. If people actually ran checkpatch it would resolve almost all of the issues I see.
Quoted 2 lines
That's the kind of thing that it seems like could be automated and improve the quality level of patches that make it to the maintainers.
Quoted 8 lines
All of these are the "simple" issues that really don't take long to resolve. We have it documented in great detail on how to set up an email client, how to format the patch, and how to get everything right on the kernelnewbies.org site. I also teach a class on this, one hour max is all it takes, unless you are at a company with a broken email system. And then all bets are off, you better just install a Linux email server in the corner to resolve your email issues, just like all the major companies did (IBM, Intel, Microsoft, etc.)
OK, all good points. It looks as though I can step up my own tooling some to make the email-to-compilation step faster so I don't spend as much time on patches with compiler warnings, that don't apply, etc. Dan C. said something similar.
The "one hour class" thing makes it sound like it takes "one hour" - but I find I have to revisit this stuff fairly regularly, and those hours add up.
Quoted 5 lines
I applaud your attempt here, and don't want to stop you from working on it, but I think the real issue is having people actually look for the documentation and tools we already have created to do this. If you make yet-another-tool, how are you going to advertise it any better than the existing
tools/documentationare?
That's definitely the key. Right now, people go through *some* process to discover how to send their first patch to LKML - somehow they often manage to do that without discovering (or choosing to use) checkpatch.pl or run some reasonable set of build tests. In order for something like what is being proposed here, the new tool would have to have to be:
1) Easier to find
2) Easier to use
3) Presented as a path to patch submission
(not an extra tool to run beforehand)
The idea being that the patch submission process would include some automated vetting, which catches trivial stuff for first-timers, but which also catches more complex things by integrating with 0-day or similar. I wouldn't mind not seeing a patch until after 0-day automatically provided feedback from all the static analyzers and config fuzz build testing if that could be seemlessly injected into the patch submission process.
I have people ask me about web based revision control tooling for Linux and other projects fairly regularly. I do believe that if we made it available, many first-timers would find it to be a much lower barrier to entry.
Of course, the output has to adhere to the current process such that it doesn't impact the scalability of our top maintainers like you and Linus.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 13 lines · On Thu, Jul 09, 2015 at 04:11:31PM -0700, [email protected] wrote:
Quoted 12 lines · Julia Lawall
Quoted 10 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 8 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Not sure to understand. Isn't it better to have the most feedback possible?
If 0-day has enough bandwidth, sure.
0-day has good enough bandwidth, now and future. :)
Quoted 5 lines
However, if this is going to
encourage a large number of new contributors to quickly iterate a pile of patches, many of which are likely to have basic procedural issues in the first few iterations, then that may waste quite a lot of build time in 0-day.
0-day can reasonably handle that kind of load. Feel free to push code 10 times per day. It'll run all build/boot tests on the latest branch HEAD until test completion or new HEAD arrives.
Thanks,
Fengguang
Quoted 7 lines · Greg KH
I applaud your attempt here, and don't want to stop you from working on it, but I think the real issue is having people actually look for the documentation and tools we already have created to do this. If you make yet-another-tool, how are you going to advertise it any better than the existing
tools/documentationare?
I don't know if i should give my opinion here. I am here for almost one year and am coming from Eudyptula. I think this thread was regarding recruitment and high dropout rates.
So from a newbie's point of view, setting up git or mutt was never a problem. Ok, maybe everyone needs to send his/her first patch two or three itmes until he gets it right in the formating or commit message or subject. But sending it using git send-email never had been a problem. In my opinion the main problem is lack of direction or guidance. As a newbie I send my first patch, it gets accepted, I have a party to celebrate and do more style correction and few more patches are accepted. But by that time I am getting bored with just style correction and want to do something more.
Now the problem starts. No one is there to guide me and I as a newbie will not be that much capable enough to find things to do on my own. And I start loosing the interest. Newbies who are coming from Eudyptula or starting on their own will face this. But on the otherhand participants of Outreachy will get a Mentor to guide them and gets a stipend to keep them motivated. Stipend may not matter to the right candidate who has interest but having a mentor is the big difference.
Another problem, when a newbie tries to move out of staging to some other subsystem he likes, the maintainer may not be that much responsive. Just for example, i submitted a patch on November, 2014 and I am yet to receive a reply or review to that and the patch was not a style correction patch.
And using git send-email and mutt with gmail is very easy, you do not need to do any change in gmail. If you want I can give my .gitconfig and .muttrc for your reference.
regards
sudip
Quoted 9 lines · Luis R. Rodriguez
Quoted 8 lines · On Thu, Jul 09, 2015 at 02:00:59PM -0700, [email protected] wrote:
Quoted 7 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Yeah true, Fengguang, is that an option?
Never mind, 0-day is powerful enough to do full-scale testing for early stage branches and expose as much errors as possible in one iteration.
Thanks,
Fengguang
[Ksummit-discuss] checkpatch.pl stuff...
In reply to Steven RostedtQuoted 3 lines · Steven Rostedt
Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
I have seen people do some very ugly things to satisfy the 80 character limit. Recently someone sent a patch to make a config description long enough for checkpatch and
the they did it
by adding by adding
lots and lots of
newlines like this. :)
Anyway, I ran checkpatch.pl on your last 500 patches to see what you were complaining about specifically.
230 WARNING: please, no spaces at the start of a line
Checkpatch doesn't handle perl well.
207 WARNING: line over 80 characters
These are over reported because of a bug in checkpatch.pl which should be fixed in Mondays linux-next.
149 ERROR: space prohibited after that open parenthesis '(' 137 ERROR: space prohibited before that close parenthesis ')'
The spaces were added deliberately to make things line up nicely. Because the table is longish then it creates a lot of warnings.
115 WARNING: Possible unwrapped commit description (prefer a maximum 75 chars per line)
These were mostly oops output and fixes-lines.
106 ERROR: trailing whitespace
43 WARNING: macros should not use a trailing semicolon
The other main issue is that trace code is written in preprocessor instead of C. It's a bit unique like that.
27 WARNING: Prefer pr_warn(... to pr_warning(...
A bunch of things are quite picky. Why don't we just sed away pr_warning() and get rid of this checkpatch warning?
18 WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
17 ERROR: Macros with complex values should be enclosed in parentheses
15 ERROR: Macros with multiple statements should be enclosed in a do - while loop
13 ERROR: space required after that ',' (ctx:VxV)
11 WARNING: Prefer seq_puts to seq_printf
10 WARNING: externs should be avoided in .c files
10 ERROR: Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.
8 WARNING: quoted string split across lines
8 WARNING: Missing a blank line after declarations
6 WARNING: use relative pathname instead of absolute in changelog text
6 WARNING: printk() should include KERN_ facility level
5 WARNING: please, no space before tabs
4 WARNING: Prefer [subsystem eg: netdev]_cont([subsystem]dev, ... then dev_cont(dev, ... then pr_cont(... to printk(KERN_CONT ...
4 WARNING: networking block comments don't use an empty /* line, use /* Comment...
4 WARNING: Macros with flow control statements should be avoided
4 ERROR: code indent should use tabs where possible
3 WARNING: Possible switch case/default not preceeded by break or fallthrough comment
3 ERROR: space required after that close brace '}'
2 WARNING: Use a single space after To:
2 WARNING: suspect code indent for conditional statements (16, 20)
2 WARNING: 'charater' may be misspelled - perhaps 'character'?
2 WARNING: braces {} are not necessary for single statement blocks
2 WARNING: 'agaist' may be misspelled - perhaps 'against'?
2 ERROR: Unrecognized email address: ''
1 WARNING: 'writting' may be misspelled - perhaps 'writing'?
1 WARNING: unnecessary whitespace before a quoted newline
1 WARNING: 'teh' may be misspelled - perhaps 'the'?
1 WARNING: struct file_operations should normally be const
1 WARNING: static const char * array should probably be static const char * const
1 WARNING: space prohibited between function name and open parenthesis '('
1 WARNING: space prohibited before semicolon
1 WARNING: simple_strtoull is obsolete, use kstrtoull instead
1 WARNING: 'seach' may be misspelled - perhaps 'search'?
1 WARNING: Possible unnecessary 'out of memory' message
The rest are spelling mistakes and minor things.
Looking through this, your code is different and special so it doesn't work for you, but you aren't dealing with as many newbies as the rest of us so that's ok.
I also ran checkpatch over the last 1000 patches from drivers/.
741 WARNING: line over 80 characters
141 WARNING: Possible unwrapped commit description (prefer a maximum 75 chars per line)
41 WARNING: added, moved or deleted file(s), does MAINTAINERS need updating?
32 ERROR: space prohibited after that open parenthesis '('
28 WARNING: quoted string split across lines
17 WARNING: braces {} are not necessary for single statement blocks
15 WARNING: Missing a blank line after declarations
11 WARNING: space prohibited between function name and open parenthesis '('
11 WARNING: please, no spaces at the start of a line
8 ERROR: code indent should use tabs where possible
6 ERROR: "foo * bar" should be "foo *bar"
5 WARNING: use relative pathname instead of absolute in changelog text
5 WARNING: Possible unnecessary 'out of memory' message
5 WARNING: msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt
4 WARNING: unnecessary whitespace before a quoted newline
4 ERROR: space required after that ',' (ctx:VxV)
3 WARNING: Use #include <linux/io.h> instead of <asm/io.h>
3 WARNING: sizeof *sctx should be sizeof(*sctx)
3 WARNING: please write a paragraph that describes the config symbol fully
3 WARNING: networking block comments don't use an empty /* line, use /* Comment...
3 WARNING: braces {} are not necessary for any arm of this statement
3 ERROR: Unrecognized email address: '[email protected]'
3 ERROR: Unrecognized email address: '[email protected]'
3 ERROR: space required after that ',' (ctx:OxV)
3 ERROR: do not use assignment in if condition
2 WARNING: Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt
2 WARNING: Use a single space after Cc:
2 WARNING: 'unecessary' may be misspelled - perhaps 'unnecessary'?
2 WARNING: sizeof(& should be avoided
2 WARNING: Single statement macros should not use a do {} while (0) loop
2 WARNING: Prefer [subsystem eg: netdev]_info([subsystem]dev, ... then dev_info(dev, ... then pr_info(... to printk(KERN_INFO ... 2 WARNING: Prefer [subsystem eg: netdev]_err([subsystem]dev, ... then dev_err(dev, ... then pr_err(... to printk(KERN_ERR ... 2 WARNING: please, no space before tabs
2 WARNING: 'overriden' may be misspelled - perhaps 'overridden'?
2 WARNING: Non-standard signature: Requested-by:
2 WARNING: Macros with flow control statements should be avoided
2 WARNING: EXPORT_SYMBOL(foo); should immediately follow its function/variable
2 WARNING: else is not generally useful after a break or return
2 WARNING: A patch subject line should describe the change not the tool that found it
2 ERROR: space required before the open parenthesis '('
2 ERROR: space required before that '&' (ctx:OxV)
Checkpatch.pl basically works for drivers. There are a lot fewer warnings and even the warnings that make it through the review process are often correct.
regards,
dan carpenter
Quoted 9 lines
All of these are the "simple" issues that really don't take long to resolve. We have it documented in great detail on how to set up an email client, how to format the patch, and how to get everything right on the kernelnewbies.org site. I also teach a class on this, one hour max is all it takes, unless you are at a company with a broken email system. And then all bets are off, you better just install a Linux email server in the corner to resolve your email issues, just like all the major companies did (IBM, Intel, Microsoft, etc.)
Quoted 5 lines
I applaud your attempt here, and don't want to stop you from working on it, but I think the real issue is having people actually look for the documentation and tools we already have created to do this. If you make yet-another-tool, how are you going to advertise it any better than the existing
tools/documentationare?
I agree that we have lots of very detailed documentation, but the process is still a bit complex, and it is easy to make a mistake before one gets a feel for it. Having an easy way to do everything in the normal way, but have the email end up at some test address rather than in the inboxes of maintainers could help people get started. On the other hand, I'm not sure that a web form would be helpful, unless there is the expectation that some peope would never use anything other than the web form. There doesn't seem to be a clear pathway from the web form to email.
julia
Re: [Ksummit-discuss] checkpatch.pl stuff...
In reply to Dan CarpenterQuoted 5 lines · Dan Carpenter
Quoted 3 lines · Steven Rostedt
Ug, don't emphasize checkpatch. I see people making patches uglier due to it. I have an old version of checkpatch that I sometimes run, but the new version, IMHO, has more noise than signal.
Quoted 7 lines
I have seen people do some very ugly things to satisfy the 80 character limit. Recently someone sent a patch to make a config description long enough for checkpatch and
the they did it
by adding by adding
lots and lots of
newlines like this. :)
The 80 character limit warning is the only thing I really dislike about checkpatch. I've seen so many patches with insane ;) line breaks just to satisfy this rule.
Unfortunately even experienced developers think this is a hard limit. Argueing that checkpatch just gives you a hint that something _could_ be improved are most of the time pointless. "But checkpatch says... therefore it has be to like that." ;)
Besides that it I think it works just fine.
Re: [Ksummit-discuss] checkpatch.pl stuff...
Quoted 9 lines · On Sat, 11 Jul 2015 13:34:47 +0200 Heiko Carstens <[email protected]>…
The 80 character limit warning is the only thing I really dislike about checkpatch. I've seen so many patches with insane ;) line breaks just to satisfy this rule.
Unfortunately even experienced developers think this is a hard limit. Argueing that checkpatch just gives you a hint that something _could_ be improved are most of the time pointless. "But checkpatch says... therefore it has be to like that." ;)Besides that it I think it works just fine.
I'll admit, as Dan said, that my patches are somewhat "special". But what I really hate, is that argument I have had with people where I comment on a patch, and they argue the "but checkpatch says". Yeah, that can get annoying.
-- Steve
Quoted 18 lines · Sudip Mukherjee
Quoted 7 lines · Greg KH
I applaud your attempt here, and don't want to stop you from working on it, but I think the real issue is having people actually look for the documentation and tools we already have created to do this. If you make yet-another-tool, how are you going to advertise it any better than the existing
tools/documentationare?I don't know if i should give my opinion here. I am here for almost one year and am coming from Eudyptula. I think this thread was regarding recruitment and high dropout rates.
So from a newbie's point of view, setting up git or mutt was never a problem. Ok, maybe everyone needs to send his/her first patch two or three itmes until he gets it right in the formating or commit message or subject. But sending it using git send-email never had been a problem. In my opinion the main problem is lack of direction or guidance. As a newbie I send my first patch, it gets accepted, I have a party to celebrate and do more style correction and few more patches are accepted. But by that time I am getting bored with just style correction and want
Quoted 8 lines
to do something more.
Now the problem starts. No one is there to guide me and I as a newbie will not be that much capable enough to find things to do on my own. And I start loosing the interest. Newbies who are coming from Eudyptula or starting on their own will face this. But on the otherhand participants of Outreachy will get a Mentor to guide them and gets a stipend to keep them motivated. Stipend may not matter to the right candidate who has interest but having a mentor is the big difference.
This is a good point. I keep thinking of making a "Stuff I don't like" blog, which would contain things that I see that look unpleasant, but that I don't have time to deal with immediately. This would contain things that are probably too complicated for checkpatch. A typical entry might be a list of functions that could be using devm functions. Such a thing could get newbies looking around in the code, seeing how things fit together, etc.
Quoted 4 lines
Another problem, when a newbie tries to move out of staging to some other subsystem he likes, the maintainer may not be that much responsive. Just for example, i submitted a patch on November, 2014 and I am yet to receive a reply or review to that and the patch was not a style correction patch.
This seems like the sort of problem that has existed since the beginning of time, and will exist unti the end of time. One has to just find something else to do, if the maintainer is completely unresponsive.
julia
Quoted 11 lines
And using git send-email and mutt with gmail is very easy, you do not need to do any change in gmail. If you want I can give my .gitconfig and .muttrc for your reference.
regards
sudip
_______________________________________________
Ksummit-discuss mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/ksummit-discuss
Quoted 4 lines · Darren Hart
OK, all good points. It looks as though I can step up my own tooling some to make the email-to-compilation step faster so I don't spend as much time on patches with compiler warnings, that don't apply, etc. Dan C. said something similar.
I think I mentioned it before, but Wolfram has a set of scripts that does this really well. I don't know if they are published anywhere, but that would be a good place to start with. I think Sara Sharp also had a bunch that she used to make life easier, you might want to ask her the next time you see her in the office.
Quoted 2 lines
The "one hour class" thing makes it sound like it takes "one hour" - but I find I have to revisit this stuff fairly regularly, and those hours add up.
Really? Why? Once you learn the workflow, what keeps changing that breaks things? External stuff (like corporate email servers), or things in our workflow/tools?
thanks,
greg k-h
Quoted 20 lines · Julia Lawall
Quoted 19 lines · Sudip Mukherjee
Quoted 8 lines · Greg KH
I applaud your attempt here, and don't want to stop you from working on it, but I think the real issue is having people actually look for the documentation and tools we already have created to do this. If you make yet-another-tool, how are you going to advertise it any better than the existing
tools/documentationare?I don't know if i should give my opinion here. I am here for almost one year and am coming from Eudyptula. I think this thread was regarding recruitment and high dropout rates.
So from a newbie's point of view, setting up git or mutt was never a problem. Ok, maybe everyone needs to send his/her first patch two or three itmes until he gets it right in the formating or commit message or subject. But sending it using git send-email never had been a problem. In my opinion the main problem is lack of direction or guidance. As a newbie I send my first patch, it gets accepted, I have a party to celebrate and do more style correction and few more patches are accepted. But by that time I am getting bored with just style correction and want
Quoted 8 lines
Quoted 8 lines
to do something more.
Now the problem starts. No one is there to guide me and I as a newbie will not be that much capable enough to find things to do on my own. And I start loosing the interest. Newbies who are coming from Eudyptula or starting on their own will face this. But on the otherhand participants of Outreachy will get a Mentor to guide them and gets a stipend to keep them motivated. Stipend may not matter to the right candidate who has interest but having a mentor is the big difference.
Thanks Sudip for sharing your experience.
Quoted 8 lines
This is a good point. I keep thinking of making a "Stuff I don't like" blog, which would contain things that I see that look unpleasant, but that I don't have time to deal with immediately. This would contain things that are probably too complicated for checkpatch. A typical entry might be a list of functions that could be using devm functions. Such a thing could get newbies looking around in the code, seeing how things fit together, etc.
Quoted 7 lines
Quoted 4 lines
Another problem, when a newbie tries to move out of staging to some other subsystem he likes, the maintainer may not be that much responsive. Just for example, i submitted a patch on November, 2014 and I am yet to receive a reply or review to that and the patch was not a style correction patch.
This seems like the sort of problem that has existed since the beginning of time, and will exist unti the end of time.
:( I'll admit it's been a problem, but I strongly disagree that it will always be that way.
afaict, there's two scenarios here: 1/ A dev wanting to help, but doesn't have a personal itch to scratch. 2/ A dev with an itch to scratch but an unresponsive maintainer.
wrt 1, there's always a lot of potential solutions for TODO lists and the like. The problem with them is they quickly become out of date, or overcome by other changes. Thus, they need to be maintained. Typically by the person knowledgeable in the subsystem. Who has little time for such activities.
We could say "Ask the maintainer" since that person usually has a list of itches a mile long. But that adds a coaching / mentoring burden to the maintainer.
Perhaps that burden could be reduced by a '[email protected]' ML? The idea is that a new contributor would Cc that in addition to the usual Cc's. Folks like me who enjoy mentoring would be subscribed and would do most of the coaching, leaving the subsystem-specific critique to the subsystem maintainers.
As for 2, I think the kernel-mentor@ could help here as well. Those of us subscribed to it know the flow of the kernel cycle, as well as the bursty nature of some of the maintainers. So we could advise "Go ahead and resend" or "Maintainer X usually applies everything around -rc7, so let's be patient."
If it works, we may even find maintainers kicking tasks they don't have time for to kernel-mentor@ ...
thx,
Jason.
Quoted 1 line · Jason Cooper
Perhaps that burden could be reduced by a '[email protected]' ML?
We already have such a mailing list, it's quite empty and quiet :(
In other words, this idea has been tried, maybe consider something else?
greg k-h
Quoted 4 lines · Greg KH
Quoted 1 line · Jason Cooper
Perhaps that burden could be reduced by a '[email protected]' ML?
We already have such a mailing list, it's quite empty and quiet :(
Are you referring to linux-newbie?
http://vger.kernel.org/vger-lists.html#linux-newbie
If so, yes. It's empty and quiet.
Quoted 1 line
In other words, this idea has been tried, maybe consider something else?
Well, the key piece is having a few experienced maintainers active on the list. That doesn't seem to be the case on linux-newbie. Also, linux-newbie doesn't seem to be kernel-specific.
We could address new users not knowing about it with a script. Any [PATCH] posts to a mailing list where the sender is a miss in the git history bounces the email to the kernel-mentor list.
In case it wasn't obvious, I'd be willing to be one of those mentors if I had a few others to rotate lead with.
thx,
Jason.
Re: [Ksummit-discuss] checkpatch.pl stuff...
In reply to Steven RostedtQuoted 11 lines · Steven Rostedt
Quoted 8 lines · On Sat, 11 Jul 2015 13:34:47 +0200 Heiko Carstens <[email protected]>…
The 80 character limit warning is the only thing I really dislike about checkpatch. I've seen so many patches with insane ;) line breaks just to satisfy this rule.
Unfortunately even experienced developers think this is a hard limit. Argueing that checkpatch just gives you a hint that something _could_ be improved are most of the time pointless. "But checkpatch says... therefore it has be to like that." ;)
Quoted 6 lines
Quoted 1 line
Besides that it I think it works just fine.
I'll admit, as Dan said, that my patches are somewhat "special". But what I really hate, is that argument I have had with people where I comment on a patch, and they argue the "but checkpatch says". Yeah, that can get annoying.
It can and does. Especially the "long_lines" message.
It'd be good if somehow checkpatch output could be viewed more as lighthearted suggestions rather than iron-clad rules.
Maybe changing the "WARNING" type messages to a new "SUGGESTION" might be better to let people know that it's OK to ignore some rules.
Maybe reclassifying some ERROR type messages to WARNING/SUGGESTION might help.
I'd like to see checkpatch used quite a bit less on files and perhaps a bit more on actual patches.
I've suggested a few things.
https://lkml.org/lkml/2015/2/11/433
o Only allow checkpatch to be used with the -f/--file option for drivers/staging/
o Add an undocumented --force command line option
o Make --strict the default for drivers/staging
I think these checkpatch style-based --type=<foo> white-space rules are generally reasonable and should nearly always be followed for basic kernel style conformance:
o spacing
o space_before_tab
o pointer_location
o trailing_whitespace
o bracket_space
o leading_space
The brace line position rules are generally reasonable:
o open_brace
o braces
o else_after_brace
o while_after_brace
The vertical line rules like "blank line after declarations" and "consecutive blank lines" are likely reasonable but may be dubious.
o line_spacing
There are some additional rules active only when the --strict option is used that some like
o spacing
(space after a cast)
(spaces around operators and arithmetic)
o line spacing
(blank line after function/struct/union/enum)
These style-based rules are perhaps a bit dubious:
o long_line
o logical_continuations
o parenthesis_alignment
This one I think senseless (minimum 4 line), but there is an override capability:
o config_description
Quoted 11 lines · Jason Cooper
Quoted 4 lines · Greg KH
Quoted 1 line · Jason Cooper
Perhaps that burden could be reduced by a '[email protected]' ML?
We already have such a mailing list, it's quite empty and quiet :(
Are you referring to linux-newbie?
http://vger.kernel.org/vger-lists.html#linux-newbie
If so, yes. It's empty and quiet.
Nope, kernel-mentors:
http://kernelnewbies.org/KernelMentors
Quoted 4 lines
Quoted 1 line
In other words, this idea has been tried, maybe consider something else?
Well, the key piece is having a few experienced maintainers active on the list.
We have that.
Quoted 2 lines
That doesn't seem to be the case on linux-newbie. Also, linux-newbie doesn't seem to be kernel-specific.
I don't know anything about linux-newbie, sorry.
Quoted 6 lines
We could address new users not knowing about it with a script. Any [PATCH] posts to a mailing list where the sender is a miss in the git history bounces the email to the kernel-mentor list.
In case it wasn't obvious, I'd be willing to be one of those mentors if I had a few others to rotate lead with.
Great, feel free to join the kernel-mentors list and be amazed at the silence :)
The fact that it's not well known might be one of the problems, but it has been tried, just pointing out that this isn't a new idea, not that it is an invalid one.
good luck!
greg k-h
Quoted 10 lines · Greg KH
Quoted 6 lines · Jason Cooper
We could address new users not knowing about it with a script. Any [PATCH] posts to a mailing list where the sender is a miss in the git history bounces the email to the kernel-mentor list.
In case it wasn't obvious, I'd be willing to be one of those mentors if I had a few others to rotate lead with.
Great, feel free to join the kernel-mentors list and be amazed at the silence :)
Subscribed.
Quoted 3 lines
The fact that it's not well known might be one of the problems, but it has been tried, just pointing out that this isn't a new idea, not that it is an invalid one.
Ack, I'll hack together a script to spot first-time patch submitters and flag them for Cc/Fwd to kernel-mentors.
thx,
Jason.
Quoted 15 lines · James Bottomley
Quoted 5 lines · On Thu, 2015-07-09 at 14:00 -0700, [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 8 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
We already have this with the 0 day project. The only difference being the patch has to be in a tree for it to get tested. It's not impossible to imagine a bot that would pick up a patch, apply it (giving automated rejects as email replies), and leave it in for the 0 day tests to
assess ... sort of like patchwork but with an automated tree build. We
could periodically throw away the tree (say weekly) because the job of the bot would be to find initial rejects rather than build a workable tree.
That's a good point. Up to now 0-day only takes care of code in git trees. We've collected 500+ developers' git trees so far, however their coverage looks not enough -- there are 3000+ kernel developers in last year's git log.
To achieve 100% code coverage, we'll also need to watch emails in the kernel mailing lists, auto convert patch series there to git branches for 0-day and other testers, and auto reply results to the original mailing list's email thread.
That would be a natural fit for the email based patch submission path and review process.
The potential problem, however, is "git-am to which base branch?" That's where it may go messy.
Thanks,
Fengguang
Quoted 16 lines · Davidlohr Bueso
Quoted 15 lines · Josh Poimboeuf
Quoted 8 lines · Steven Rostedt
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
I'm relatively new to lkml so my perceptions might be skewed. But it seems to me that, for non-trivial patches, the Reviewed-by tag is pretty much useless as a metric. From what I can tell, the biggest problems with relying on Reviewed-by to get meaningful statistics are:
Quoted 8 lines
Quoted 5 lines
1. It's self-reported by the reviewer.
Maybe a reviewer gave some hugely valuable feedback in versions 1-4 of the patch, but wasn't around to provide the Reviewed-by tag for the final v6.
Normally good maintainers pick up ack/review tags along the way when they pickup the final patch.
A maintainer can't pick up the tag if the reviewer doesn't post it.
In this example the reviewer wouldn't have posted Reviewed-by because, despite the fact that they did a thorough review, the patch still had issues in its earlier versions. The reviewer did a lot of work but didn't get credit for it.
Quoted 10 lines
Quoted 5 lines
Or maybe they're just focused on the review, and forget or don't care to ask for credit for it at the time by adding a tag.
Or maybe they're a maintainer who used Signed-off-by instead (but Signed-off-by doesn't necessarily imply a review).
At least at some level any patches picked up by a maintainer should at least be compile tested and looked at any obvious issues -- when the maintainer trusts other devs/submaintainers that did the more thorough review process.
Right, as I said, Signed-off-by doesn't necessarily imply Reviewed-by.
So any review done by a maintainer who only adds Signed-off-by goes uncredited.
Quoted 20 lines
Quoted 2 lines
Also, as others have mentioned, it creates the ability to game the system by saying you've reviewed a patch when you really haven't.
The system can always be gamed.
Quoted 15 lines
2. It's too broad of a statement. It requires the reviewer to make an official certification that they fully understand and approve of the *entire* patch. That's certainly a useful statement, but:
A reviewer might review only part of the patch, and provide some useful comments for just the part of the patch they reviewed. But they don't want to take responsibility for saying, to quote Steven, "I took enough effort to understand every part of the patch as if I wrote it myself."
Or maybe they didn't carefully review the patch, but instead added something valuable to the discussion which improved the patch in a future version.
Quoted 5 lines
Quoted 2 lines
So it denies credit to all the other people who provided useful comments along the way.
Mentioning/thanking others that helped in any meaningful way is always a good idea.
Sure, but if you only thank them informally then their contribution can't be quantified, which was one of the proposed goals of this discussion.
Quoted 19 lines
Quoted 6 lines
Review comments such as "here's a problem with your code" or "have you thought about doing this instead?" can often be more useful a comment than "your code looks good". Maybe it would be a good idea to acknowledge those people who give valuable feedback, in all its forms. Maybe a new tag would be useful? Something which:
Quoted 7 lines
a) is reported by the patch author and/or maintainer, since they're in the best position to keep track of useful comments across versions;
and
b) means something like "I'm grateful to this person for giving some valuable feedback".
A tag for this? Nah.
Thanks,
Davidlohr
Signature · 1 line
Josh
Quoted 34 lines · Fengguang Wu
Quoted 15 lines · James Bottomley
Quoted 5 lines · On Thu, 2015-07-09 at 14:00 -0700, [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 8 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
We already have this with the 0 day project. The only difference being the patch has to be in a tree for it to get tested. It's not impossible to imagine a bot that would pick up a patch, apply it (giving automated rejects as email replies), and leave it in for the 0 day tests to
assess ... sort of like patchwork but with an automated tree build. We
could periodically throw away the tree (say weekly) because the job of the bot would be to find initial rejects rather than build a workable tree.That's a good point. Up to now 0-day only takes care of code in git trees. We've collected 500+ developers' git trees so far, however their coverage looks not enough -- there are 3000+ kernel developers in last year's git log.
To achieve 100% code coverage, we'll also need to watch emails in the kernel mailing lists, auto convert patch series there to git branches for 0-day and other testers, and auto reply results to the original mailing list's email thread.
Quoted 5 lines
That would be a natural fit for the email based patch submission path and review process.
The potential problem, however, is "git-am to which base branch?" That's where it may go messy.
Patch submitters should be making it clear to what tree their patch applies, preferably using an unambiguous tag in the mail subject. In the absence of such a tag, try it against torvalds/linux.git and linux-next.git, and then give up and tell the submitter to specify what their patch applies to.
- Josh Triplett
Quoted 26 lines · Josh Poimboeuf
Quoted 16 lines · Davidlohr Bueso
Quoted 15 lines · Josh Poimboeuf
Quoted 8 lines · Steven Rostedt
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
I'm relatively new to lkml so my perceptions might be skewed. But it seems to me that, for non-trivial patches, the Reviewed-by tag is pretty much useless as a metric. From what I can tell, the biggest problems with relying on Reviewed-by to get meaningful statistics are:
Quoted 8 lines
Quoted 5 lines
1. It's self-reported by the reviewer.
Maybe a reviewer gave some hugely valuable feedback in versions 1-4 of the patch, but wasn't around to provide the Reviewed-by tag for the final v6.
Normally good maintainers pick up ack/review tags along the way when they pickup the final patch.
Quoted 6 lines
A maintainer can't pick up the tag if the reviewer doesn't post it.
In this example the reviewer wouldn't have posted Reviewed-by because, despite the fact that they did a thorough review, the patch still had issues in its earlier versions. The reviewer did a lot of work but didn't get credit for it.
And that's not always a bad thing. Sometimes I review the previous version of a patch, and then see that tag applied to a later version that is substantially different from the version I reviewed; that makes me uncomfortable. I care less about getting credit for a review and more about not having my Reviewed-by tag attached to something I didn't review. (Obviously, this is a fuzzy thing; for instance, if three people note issues and offer a Reviewed-by with those issues fixed, fixing all the issues and applying all three Reviewed-by tags seems reasonable.)
- Josh Triplett
Quoted 38 lines · Josh Triplett
Quoted 37 lines · Fengguang Wu
Quoted 15 lines · James Bottomley
Quoted 5 lines · On Thu, 2015-07-09 at 14:00 -0700, [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 8 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
We already have this with the 0 day project. The only difference being the patch has to be in a tree for it to get tested. It's not impossible to imagine a bot that would pick up a patch, apply it (giving automated rejects as email replies), and leave it in for the 0 day tests to
assess ... sort of like patchwork but with an automated tree build. We
could periodically throw away the tree (say weekly) because the job of the bot would be to find initial rejects rather than build a workable tree.That's a good point. Up to now 0-day only takes care of code in git trees. We've collected 500+ developers' git trees so far, however their coverage looks not enough -- there are 3000+ kernel developers in last year's git log.
To achieve 100% code coverage, we'll also need to watch emails in the kernel mailing lists, auto convert patch series there to git branches for 0-day and other testers, and auto reply results to the original mailing list's email thread.
That would be a natural fit for the email based patch submission path and review process.
Quoted 8 lines
Quoted 2 lines
The potential problem, however, is "git-am to which base branch?" That's where it may go messy.
Patch submitters should be making it clear to what tree their patch applies, preferably using an unambiguous tag in the mail subject. In the absence of such a tag, try it against torvalds/linux.git and linux-next.git, and then give up and tell the submitter to specify what their patch applies to.
To be honest, the mailing list it's sent to mostly identifies which tree it should be going in. There's difficulty over whether the for next or for current branches ... but we have that today as well.
James
Quoted 8 lines · David Woodhouse
Quoted 7 lines · Steven Rostedt
Quoted 2 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart <[email protected]> wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer
+1000
Quoted 8 lines
Quoted 3 lines
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
"Importing" patches in emails is one of the major reasons why they become corrupted.
Quoted 4 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
"vi 0*patch"?
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Quoted 7 lines · Josh Boyer
Quoted 2 lines
Can one still send "from" GMail via SMTP these days? How does the 2 -factor authentication work? Do we cope with that?
You can, but it doesn't support 2FA. You have to generate one of those "device" or "application" passwords and use that instead. Things might have changed since I last set it up, but that is what I had to do to use google SMTP via mutt.
Yes, works fine. I use that on my laptop (at home I have local SMTP).
Add to .gitconfig:
[sendemail]
smtpencryption = tls
smtpserver = smtp.gmail.com
smtpuser = [email protected]
smtppass = secret-app-password
smtpserverport = 587
I'd actually encourage newcomers to use that, is it teaches them how to set up device or app-specific passwords, too ;-)
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Quoted 3 lines · On Fri, Jul 10, 2015 at 11:07 PM, <[email protected]> wrote:
I just wish I had a more satisfactory method of associating a cover letter with a series *in git*, such that format-patch could emit a non-placeholder cover letter.
You can use "git commit --allow-empty" to write cover letters. Make sure they don't get lost during rebasing.
Still, if you include them in --format-patch, they will be "PATCH 1/n", not "PATCH 0/n".
[...]
Oh cool, there's a "--start-number" option, will try...
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Quoted 48 lines · James Bottomley
Quoted 38 lines · Josh Triplett
Quoted 37 lines · Fengguang Wu
Quoted 15 lines · James Bottomley
Quoted 5 lines · On Thu, 2015-07-09 at 14:00 -0700, [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 8 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
We already have this with the 0 day project. The only difference being the patch has to be in a tree for it to get tested. It's not impossible to imagine a bot that would pick up a patch, apply it (giving automated rejects as email replies), and leave it in for the 0 day tests to
assess ... sort of like patchwork but with an automated tree build. We
could periodically throw away the tree (say weekly) because the job of the bot would be to find initial rejects rather than build a workable tree.That's a good point. Up to now 0-day only takes care of code in git trees. We've collected 500+ developers' git trees so far, however their coverage looks not enough -- there are 3000+ kernel developers in last year's git log.
To achieve 100% code coverage, we'll also need to watch emails in the kernel mailing lists, auto convert patch series there to git branches for 0-day and other testers, and auto reply results to the original mailing list's email thread.
That would be a natural fit for the email based patch submission path and review process.
Quoted 8 lines
Quoted 2 lines
The potential problem, however, is "git-am to which base branch?" That's where it may go messy.
Patch submitters should be making it clear to what tree their patch applies, preferably using an unambiguous tag in the mail subject. In the absence of such a tag, try it against torvalds/linux.git and linux-next.git, and then give up and tell the submitter to specify what their patch applies to.
Quoted 3 lines
To be honest, the mailing list it's sent to mostly identifies which tree it should be going in. There's difficulty over whether the for next or for current branches ... but we have that today as well.
Yes, mailing list would be a very good hint.
Another clue can be the index part of all git emails
diff --git a/Makefile b/Makefile
==> index 3ba5044..f5c8983 100644
--- a/Makefile
+++ b/MakefileThat object id may help identify the possible BASE branches for the email patch. Due to my limited knowledge of git, I can only think about a brutal force (but still affordable) way to iterate all the well known branches to find the possible BASE branches.
Thanks,
Fengguang
Quoted 9 lines · Darren Hart
Quoted 4 lines · Roberto Tyley
It would be great to turn on submitGit for development of the Linux Kernel. Just to clarify, submitGit is a bridge for sending GitHub pull requests on https://github.com/git/git to [email protected] as correctly formatted emails
While there is value there and would help a lot of people, given the popularity of git-hub, I think we're looking for something more generic.
Quoted 7 lines
I'd prefer a web-form hosted on kernel.org that could accept a raw patch, or a git URL and tag or branch from any reposiory (github or otherwise), and submit the patch after performing a number of validation checks before ever sending to the list.
I understand this maybe isn't an extension of submitGit, but the concept of submitGit is interesting from a precedence perspective.
Fair enough - glad to provide a precedent, if not an implementation!
Quoted 2 lines
P.S. I don't know if your top posting was intentional (very clever) or accidental (case in point), but either way it's dripping with irony. ;-)
Totally unintentional irony :-)
Quoted 34 lines · Josh Triplett
Quoted 26 lines · Josh Poimboeuf
Quoted 16 lines · Davidlohr Bueso
Quoted 15 lines · Josh Poimboeuf
Quoted 8 lines · Steven Rostedt
I personally don't trust a Reviewed-by tag much, as I sometimes see them appear without any comments.
I was thinking of writing a perl script that would read my LKML archive and somewhat intelligently looking at people who replied to patches, that also has snippets of the patch in the reply, and counting them. I think that would be a more accurate use of real reviewers than just the Reviewed-by tag.
I'm relatively new to lkml so my perceptions might be skewed. But it seems to me that, for non-trivial patches, the Reviewed-by tag is pretty much useless as a metric. From what I can tell, the biggest problems with relying on Reviewed-by to get meaningful statistics are:
Quoted 8 lines
Quoted 5 lines
1. It's self-reported by the reviewer.
Maybe a reviewer gave some hugely valuable feedback in versions 1-4 of the patch, but wasn't around to provide the Reviewed-by tag for the final v6.
Normally good maintainers pick up ack/review tags along the way when they pickup the final patch.
Quoted 6 lines
A maintainer can't pick up the tag if the reviewer doesn't post it.
In this example the reviewer wouldn't have posted Reviewed-by because, despite the fact that they did a thorough review, the patch still had issues in its earlier versions. The reviewer did a lot of work but didn't get credit for it.
Quoted 6 lines
And that's not always a bad thing. Sometimes I review the previous version of a patch, and then see that tag applied to a later version that is substantially different from the version I reviewed; that makes me uncomfortable. I care less about getting credit for a review and more about not having my Reviewed-by tag attached to something I didn't review.
If our goal is to quantify the work of good reviewers, so that we can shine a light on them and hopefully motivate them to do more review, then I'd argue that having a reviewer doing a lot of work and not getting credit for it *is* a bad thing.
I agree that the Reviewed-by tag doesn't apply here. It communicates patch approval, rather than review helpfulness. That's why I proposed a new tag from the patch author and/or maintainer.
Signature · 1 line
Josh
Quoted 8 lines · Geert Uytterhoeven
Quoted 3 lines · On Fri, Jul 10, 2015 at 11:07 PM, <[email protected]> wrote:
I just wish I had a more satisfactory method of associating a cover letter with a series *in git*, such that format-patch could emit a non-placeholder cover letter.
You can use "git commit --allow-empty" to write cover letters. Make sure they don't get lost during rebasing.
Quoted 6 lines
Still, if you include them in --format-patch, they will be "PATCH 1/n", not "PATCH 0/n".
[...]
Oh cool, there's a "--start-number" option, will try...
That's an amusing idea, though as you said, rebase will tend to throw them away. I've also seen cover letters done via git notes, but never in a very satisfactory way. Ideally, I'd love to see a message associated with a given branch, such that that message can become the cover letter, and if the branch gets merged that's the default merge message.
Quoted 62 lines · Fengguang Wu
Quoted 48 lines · James Bottomley
Quoted 38 lines · Josh Triplett
Quoted 37 lines · Fengguang Wu
Quoted 15 lines · James Bottomley
Quoted 5 lines · On Thu, 2015-07-09 at 14:00 -0700, [email protected] wrote:
Quoted 4 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
Quoted 8 lines
Quoted 4 lines
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-bot
That would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
We already have this with the 0 day project. The only difference being the patch has to be in a tree for it to get tested. It's not impossible to imagine a bot that would pick up a patch, apply it (giving automated rejects as email replies), and leave it in for the 0 day tests to
assess ... sort of like patchwork but with an automated tree build. We
could periodically throw away the tree (say weekly) because the job of the bot would be to find initial rejects rather than build a workable tree.That's a good point. Up to now 0-day only takes care of code in git trees. We've collected 500+ developers' git trees so far, however their coverage looks not enough -- there are 3000+ kernel developers in last year's git log.
To achieve 100% code coverage, we'll also need to watch emails in the kernel mailing lists, auto convert patch series there to git branches for 0-day and other testers, and auto reply results to the original mailing list's email thread.
That would be a natural fit for the email based patch submission path and review process.
Quoted 8 lines
Quoted 2 lines
The potential problem, however, is "git-am to which base branch?" That's where it may go messy.
Patch submitters should be making it clear to what tree their patch applies, preferably using an unambiguous tag in the mail subject. In the absence of such a tag, try it against torvalds/linux.git and linux-next.git, and then give up and tell the submitter to specify what their patch applies to.
Quoted 3 lines
To be honest, the mailing list it's sent to mostly identifies which tree it should be going in. There's difficulty over whether the for next or for current branches ... but we have that today as well.
Yes, mailing list would be a very good hint.
Another clue can be the index part of all git emails
diff --git a/Makefile b/Makefile ==> index 3ba5044..f5c8983 100644 --- a/Makefile +++ b/Makefile
Quoted 4 lines
That object id may help identify the possible BASE branches for the email patch. Due to my limited knowledge of git, I can only think about a brutal force (but still affordable) way to iterate all the well known branches to find the possible BASE branches.
That's a good idea.
- Josh Triplett
Quoted 50 lines · On Wednesday 08 July 2015 09:04:58 Peter Hüwe wrote:
Am Mittwoch, 8. Juli 2015, 04:03:04 schrieb Krzysztof Kozłowski:
Quoted 5 lines
Before doing some work there is always a cause, an answer to "why I am doing this"? Employer may pay for my commits but would he pay for reviewing time? That is his decision and it would be difficult to change policies inside companies.
Quoted 8 lines
Other reason for doing open source work may be the fame. Being recognizable, getting better job offers, doing tasks which are sensible and meaningful for someone. Currently probably most of the fame goes to authors and maintainers. For example in the form of
git log --author/committer=or LWN articles about statistics.How to get more reviews from such people (when employer does not pay for it)? Give them fame! :)
Exactly!
This is also what Rafael wrote in the other mail:
Quoted 3 lines
Most of the time there's a little to no recognition for doing that work and, quite frankly, writing code is more rewarding than that for the majority of people anyway.
So changing our fame-statistics from commits to reviews and tested by might change the situation a bit.
-> The next LWN stats and coverage should probably focus on the reviewed-by / tested-by stats.
People love to be on some "top 10" lists - and also they can show something like that to their bosses."I've been a kernel reviewer and tester" -- meh, who cares
"I've been a top 100 kernel reviewer and tester over the last X releases" -- give him a raise/the job (esp. if kernel is not the core competency of the company :)Another thing I noticed over the last few years (also in corporate), people get really motivated by memorabilia - "tokens of appreciation". E.g. I constantly wear my Google T-Shirt which I received for a contribution with such proud and so often that it is almost faded --- but still everytime I look at it I have a good feeling.
--> Maybe LF can organize something?
"Here is a small token of appreciation (t-shirt, cup) for spending countless hours on reviewing and testing stuff in the Linux kernel -- keep up the good work"Quoted 3 lines
The only way to address this problem I can see is to recognize reviewers *much* more than we tend to do and not just "encourage" them, because that's way insufficient.
Quoted 7 lines
Yes again!
What I definitely would also recommend is to organize some 'get togethers', like a miniconf/minisummit at the next conference near you -- and where you grab a beer _together_ with the reviewers / testers afterwards (and maybe the maintainer can pay).
This also helps as forms of appreciation.
While real life meetings are invaluable, let's not forgot that they also have a major drawback: not everybody can attend them. In a very distributed development environment like the Linux kernel contributors come from many different horizons, and not all of them can afford to attend conferences (or sometimes just don't want to, for various reasons). If we focus too much on a groups of contributors who can meet in real life we'll alienate the rest of the "online" crowd, and risk losing contributors who will feel left out.
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 45 lines · On Thursday 09 July 2015 01:09:00 Rafael J. Wysocki wrote:
Quoted 36 lines · Jason Cooper
Quoted 28 lines · Peter Huewe
Quoted 21 lines
Quoted 6 lines
For testers it's usually even worse - how many patches are actually tested? Judging from what I read on LKML not that many.
So we should definitely discuss:
- how can we encourage hobbyists to become regular contributors -- how to keep people interested, the drop-out rates are huge.Here we need to have the correct mindset. Kernel development is hard, detailed work. It's very rewarding, but simply put, most people aren't cut out to do it. I view the dropout rate as a *good* thing. It's a _selection_ process more than a education/training process.
With most of the hard jobs in life, take a look at the training/education program, and you'll see it: 80% drop out rate? That's selection. Kernel work is one of those 'hard jobs'.
This is important to realize because it changes how we view recruitment. We shouldn't be trying to keep everybody we recruit. Rather, we should be giving more people trial runs and see how they work out as they learn the process.
Quoted 6 lines
iow, if an 80% drop out rate gives us the caliber of dev we need for the long term health of the community, then it's a numbers game. Say we saw 40 new people last year, which turned into 8 regular contributors. Now we want to double that. We can lower the standard to get 16 out of 40, yuck. Or, we can outreach to 80 for trial runs, and get 16.
Quoted 6 lines
I think that's an interesting take on the topic - although I'm not 100% whether I agree with everything. I agree that our goal is not to lower the standards, and also using more "trial runs".
However high standards should not be the reason to drive people away -- and especially not the reason not to keep good people interested.
Quoted 7 lines
Sure, I'm not suggesting anything like testing or anything formal. Merely that everyone understand there's an attrition rate, and that's *ok*.
Recruitment, imo, isn't about trying to keep everyone that tries. Rather it's about opening the doors and providing real opportunities for more people to contribute.
Quoted 6 lines
The opportunities are there, but in addition to the opportunities themselves people need some incentives to use them. It's all about their time which they can spend in many ways, some of them more rewarding than others.
If they don't have an incentive, an opportunity itself may not be sufficient.
We also need to ensure that the opportunities can be identified as such by potential newcomers. As core kernel contributors it's easy for us to see the myriad of places where a newcomer could help, but it's much harder to do so when you have no experience with kernel development. Projects such as kernel janitors can help in that regard, but might not be enough.
There's also the issue that the kernel (and its developers) is often seen as a scary beast. I've heard too many programmers saying that contributing to the Linux kernel is too difficult, without having given it a try. We are seen as experts by the outside world. There's nothing wrong with that as such, but I believe we should work on broadcasting the message that newcomers should still give it a try.
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 5 lines · On Sat, 11 Jul 2015 22:48:24 -0500 Josh Poimboeuf <[email protected]> wrote:
Right, as I said, Signed-off-by doesn't necessarily imply Reviewed-by.
So any review done by a maintainer who only adds Signed-off-by goes uncredited.
A Signed-off-by sure as well better mean a reviewed by! It holds a much heavier meaning to the patch than a Reviewed-by does.
A Signed-off-by means that you are responsible for that patch. Even if you don't necessarily understand the patch (like a high level maintainer pulling in patches for low level hardware that the maintainer doesn't fully understand), you should review it as much as you can before adding an SoB to it. Otherwise you are not doing your job.
And regardless, there's more weight for "credit" to Signed-off-by's than for Reviewed-by's anyway. So much so, that my own scripts for analysis ignores all other tags for anyone with a Signed-off-by attached to a commit.
-- Steve
Am Samstag, 11. Juli 2015, 17:04:37 schrieb Greg KH:
Quoted 11 lines · Darren Hart
Quoted 4 lines
OK, all good points. It looks as though I can step up my own tooling some to make the email-to-compilation step faster so I don't spend as much time on patches with compiler warnings, that don't apply, etc. Dan C. said something similar.
I think I mentioned it before, but Wolfram has a set of scripts that does this really well. I don't know if they are published anywhere, but that would be a good place to start with. I think Sara Sharp also had a bunch that she used to make life easier, you might want to ask her the next time you see her in the office.
They are called ninja-check and published here
https://lists.linuxfoundation.org/pipermail/ksummit-discuss/2014-May/000554.html
Ksummit Thread about all these tools can be found here:
ftp://kernel.mirrors.pair.com/pub/linux/kernel/people/paulmck/LKS/LKS2014Topic/000291.html
Thanks,
Peter
Quoted 25 lines · On Thursday 09 July 2015 19:35:39 Julia Lawall wrote:
Quoted 15 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 14 lines · Julia Lawall
Quoted 12 lines · On Thu, 9 Jul 2015, [email protected] wrote:
Quoted 7 lines · Luis R. Rodriguez
Quoted 2 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
Bonus if this is also wired into the 0day bot, so that you also find out if you introduce a new warning or error.
No reason to make bots do stupid work, if we really wanted to consider this a bit more seriously the pipeline could be:
mailing-list | coccinelle coccicheck| smatch | sparse | 0-day-botThat would effectively make the bot duplicate part of 0-day. Seems easier to have some way to tell 0-day "if you see obvious procedural issues, don't bother with full-scale testing, just reject".
Quoted 8 lines
Quoted 2 lines
Not sure to understand. Isn't it better to have the most feedback possible?
If 0-day has enough bandwidth, sure. However, if this is going to encourage a large number of new contributors to quickly iterate a pile of patches, many of which are likely to have basic procedural issues in the first few iterations, then that may waste quite a lot of build time in 0-day.
Quoted 4 lines
My understanding was that there were plenty of computational resources available. I would think that a new contributor would like the most assurance possible that his next attempt would be successful, and thus would prefer to have all the information at once.
I can't help feeling we're mixing two issues here.
The first topic we're trying to address is recruitment. From that point of view, giving as much feedback as possible to newcomers is good as long as we can make the automatic feedback constructive. An automated reply along the lines of
"You have tried to send a patch through e-mail to the [email protected] mailing list. We have detected that your e-mail includes HTML content. This is not allowed for the reasons explained at [...]. Please configure your e-mail client to send plain text only and resend the patch. Instructions on how to do so far popular e-mail clients can be found at [...]"
would be useful. On the other hand, an automated reply from a build bot that just splits errors back without taking the newcomer by the hand will scare people off (at this point I can't help but quote the following C++ compiler error message from [1]:
Syntax error: unmatched thing in thing from std::nonstd::_ _ map<_Cyrillic, _$$$dollars>const basic_string< epic_ mystery,mongoose_traits < char>, _ _default_alloc_<casual_ Fridays = maybe>>)
This could be considered as some form of a selection process, but we don't want to make it unnecessarily painful.
The second issue we're trying to address here is how to prevent maintainers overloading caused by newcomers mistakes. This is certainly a valuable effort, and even more so if our recruitment effort becomes successful, but I see it more as a necessary consequence of improved recruitment. It would be a shame if it raised the barrier to entry for kernel contributions.
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 16 lines · On Friday 10 July 2015 21:00:12 David Woodhouse wrote:
Quoted 9 lines · Steven Rostedt
Quoted 3 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer>
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
Quoted 4 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Certainly not, but what prevents you from doing that with git-send-email ? In my workflow I always format patches with git-format-patch, proof-read them with my favourite $EDITOR and then use git-send-email to send them.
Quoted 3 lines
Perhaps we should provide tools which make it trivial to do the same for various different mail clients, without users having to know where, and in what form, their drafts folders are?
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 9 lines · On Fri, Jul 10, 2015 at 01:40:05PM -0700, [email protected] wrote:
Quoted 3 lines · Mark Brown
The false positives are a bit of an issue since it discourages people doing smaller cleanups over wide areas, you can end up getting CCed on lots of things you touched which can be a bit offputting.
--git-fallback seems to work pretty well. It nicely embodies the approach of "if it doesn't have a maintainer, talk to the last poor sucker who touched it".
That seems to have the same problems as just plain old git, and given the way it uses wildcards it will use git more often than it should for common patterns like companies supporting all their devices. It'll just trigger a bit less often.
Quoted 17 lines · Laurent Pinchart
Quoted 16 lines · On Friday 10 July 2015 21:00:12 David Woodhouse wrote:
Quoted 9 lines · Steven Rostedt
Quoted 3 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer>
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
Quoted 8 lines
Quoted 4 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Certainly not, but what prevents you from doing that with git-send-email ? In my workflow I always format patches with git-format-patch, proof-read them with my favourite $EDITOR and then use git-send-email to send them.
Apparently some people think you should feed a rev-list to git-send-email (a feature I learned about only recently), instead of patches created by git-format-patch. As you need the patches for checkpatch.pl anyway...
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Quoted 24 lines · On Monday 13 July 2015 12:11:42 Geert Uytterhoeven wrote:
Quoted 23 lines · Laurent Pinchart
Quoted 21 lines · On Friday 10 July 2015 21:00:12 David Woodhouse wrote:
Quoted 10 lines · Steven Rostedt
Quoted 3 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer>
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Quoted 7 lines
Quoted 3 lines
Certainly not, but what prevents you from doing that with git-send-email ? In my workflow I always format patches with git-format-patch, proof-read them with my favourite $EDITOR and then use git-send-email to send them.
Apparently some people think you should feed a rev-list to git-send-email (a feature I learned about only recently), instead of patches created by git-format-patch. As you need the patches for checkpatch.pl anyway...
Passing a revlist to git-send-email seems like asking for trouble, I certainly wouldn't recommend that. I use git-send-email as a glorified sendmail, I've even used it recently to send a party invitation to a large number of friends :-)
Signature · 3 lines
Regards, Laurent Pinchart
Quoted 5 lines · Josh Triplett
Patch submitters should be making it clear to what tree their patch applies, preferably using an unambiguous tag in the mail subject. In the absence of such a tag, try it against torvalds/linux.git and linux-next.git, and then give up and tell the submitter to specify what their patch applies to.
This does get complicated rapidly when people have trees with multiple branches, or when people start basing work on other pending serieses. It's easy to indicate, but doing so in a way that a machine can cope with gets harder.
Quoted 14 lines · Michael Ellerman
Quoted 5 lines · Daniel Vetter
Quoted 3 lines · Bjorn Helgaas
I wish I knew how to use patchwork better, or had a smarter workflow that could comprehend a series as a single entity. Patchwork is a lot of clicking, but I don't know anything better.
Quoted 7 lines
We're working on improving patchwork here to understand series and help out with auto-deprecating patches when new versions show up. Currently being tested internally and we plan to push to upstream ofc and deploy on freedesktop.org (since that's where all the drm/gfx folks hang out), but because of all the things going on it's really slow. Damien knows more, maybe we could push the current state to some git branch somewhere.
Quoted 4 lines
I'd be interested in that if you can publish it somewhere.
At the moment I have a very hacky script that tries to recognise a series on the client, which usually works, but not always.
I have quite a few patches on top of upstream now. It's really a back burner distraction, so well, I have no ETA to give for when I'd be happy with the state of this work.
I have a work-in-progress branch here:
https://github.com/dlespiau/patchwork
What's on there is roughly a re-design of the interface, a new REST API and parsing/presenting series to the user, not just patches.
I have some more work (unpublished because not quite ready) on top of this to parse and present new versions/revisions of series when:
- people post a v2/3/4/... of a patch as a reply to one of the series
- people post a full new series as a v2/3/4/..
The goal being one series object (with a unique ID for that patchwork instance) represents the whole life cycle of that work, including multiple versions.
Signature · 1 line
Damien
Quoted 3 lines · Josh Poimboeuf
I agree that the Reviewed-by tag doesn't apply here. It communicates patch approval, rather than review helpfulness. That's why I proposed a new tag from the patch author and/or maintainer.
I've lobbied for:
With-Fixes-from: xxx
It would only be given for actual bug fixes and not for complaining about the subject line, white space or spelling mistakes.
regards,
dan carpenter
Quoted 11 lines · Dan Carpenter
Quoted 3 lines · Josh Poimboeuf
I agree that the Reviewed-by tag doesn't apply here. It communicates patch approval, rather than review helpfulness. That's why I proposed a new tag from the patch author and/or maintainer.
I've lobbied for:
With-Fixes-from: xxx
It would only be given for actual bug fixes and not for complaining about the subject line, white space or spelling mistakes.
This seems like overengineering to me. I usually give a credit in the changelog if I find someone's contribution big enough. Also a persistent reviewer will eventually get his credit via Reviewed-by :). So I don't think yet another tag is really necessary.
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Quoted 17 lines · Laurent Pinchart
Quoted 16 lines · On Friday 10 July 2015 21:00:12 David Woodhouse wrote:
Quoted 9 lines · Steven Rostedt
Quoted 3 lines · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart wrote:
As far as recruitment goes, I think we're talking about barriers to first-timers and such - and git-send-email is one of those things. Eventually, a developer>
+1000
I still don't use git-send-email, as I afraid that I'll blow it and end up sending a thousand patches to every developer that ever touched the kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not hard to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
Quoted 9 lines
Quoted 4 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Certainly not, but what prevents you from doing that with git-send-email ? In my workflow I always format patches with git-format-patch, proof-read them with my favourite $EDITOR and then use git-send-email to send them.
This exactly mateches my workflow (with an added 0000-Summary for patch series where needed).
Guenter
Quoted 10 lines · Jan Kara
Quoted 9 lines · Dan Carpenter
Quoted 3 lines · Josh Poimboeuf
I agree that the Reviewed-by tag doesn't apply here. It communicates patch approval, rather than review helpfulness. That's why I proposed a new tag from the patch author and/or maintainer.
I've lobbied for:
With-Fixes-from: xxx
Quoted 7 lines
Quoted 2 lines
It would only be given for actual bug fixes and not for complaining about the subject line, white space or spelling mistakes.
This seems like overengineering to me. I usually give a credit in the changelog if I find someone's contribution big enough. Also a persistent reviewer will eventually get his credit via Reviewed-by :). So I don't think yet another tag is really necessary.
I could get as many reviewed-by tags as I wanted... I basically only write reviewed-by tags as a way of being nice to people sending patches.
Lots of people give credit for fixes in the changlog like but it's more common to leave it out. Also it's not searchable.
This happened hours ago in staging. Someone sent a buggy patch and reviewers spotted the bug but no one got credit.
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072662.html
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072668.html
Imagine how special Patrick would feel if we gave him a nice "With-fix-from: Patrick Farrell <[email protected]>" tag. :) Also the other rule would be that only the first person to report the bug gets the credit (Sorry, Sudip). The next version of the patch had a process problem which Sudip noticed as well but that still doesn't earn a with-fix-from tag.
regards,
dan carpenter
Quoted 37 lines · Dan Carpenter
Quoted 3 lines · Jan Kara
Quoted 2 lines · Dan Carpenter
Quoted 1 line · Josh Poimboeuf
I agree that the Reviewed-by tag doesn't apply here. It
communicates
Quoted 1 line
Quoted 1 line
Quoted 1 line
patch approval, rather than review helpfulness. That's why I
proposed a
Quoted 10 lines
Quoted 8 lines
Quoted 1 line
new tag from the patch author and/or maintainer.
I've lobbied for:
With-Fixes-from: xxx
It would only be given for actual bug fixes and not for complaining about the subject line, white space or spelling mistakes.
This seems like overengineering to me. I usually give a credit in the
changelog
Quoted 1 line
if I find someone's contribution big enough. Also a persistent
reviewer will
Quoted 1 line
eventually get his credit via Reviewed-by :). So I don't think yet
another
Quoted 1 line
tag is really necessary.
I could get as many reviewed-by tags as I wanted... I basically only write reviewed-by tags as a way of being nice to people sending patches.
Lots of people give credit for fixes in the changlog like but it's more common to leave it out. Also it's not searchable.
This happened hours ago in staging. Someone sent a buggy patch and reviewers spotted the bug but no one got credit.
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072662.html
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072668.html
Quoted 7 lines
Imagine how special Patrick would feel if we gave him a nice "With-fix-from: Patrick Farrell <[email protected]>" tag. :) Also the other
rule would be that only the first person to report the bug gets the credit (Sorry, Sudip). The next version of the patch had a process problem which Sudip noticed as well but that still doesn't earn a with-fix-from tag.
I like this idea in principle. Not entirely sure if it will work perfectly in practice.
Likely that in high revision count series some earlier work will not get credit...
Unless patch authors get to propose such tags as suggestions to the maintainer. Preferably with description in the change log! Guessing I am not the only maintainer who doesn't keep up with all the versions of some patches other than a quick controversy check!
Quoted 8 lines
regards,
dan carpenter_______________________________________________
Ksummit-discuss mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/ksummit-discuss
Signature · 1 line
Sent from my Android device with K-9 Mail. Please excuse my brevity.
Quoted 30 lines · Guenter Roeck
Quoted 4 lines · Laurent Pinchart
Quoted 3 lines · On Friday 10 July 2015 21:00:12 David Woodhouse wrote:
Quoted 2 lines · Steven Rostedt
Quoted 1 line · On Thu, 9 Jul 2015 19:07:06 -0700 Darren Hart wrote:
As far as recruitment goes, I think we're talking about
barriers to
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
first-timers and such - and git-send-email is one of those
things.
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 1 line
Eventually, a developer>
+1000
I still don't use git-send-email, as I afraid that I'll blow it
and end
Quoted 1 line
Quoted 1 line
Quoted 1 line
up sending a thousand patches to every developer that ever
touched the
Quoted 4 lines
Quoted 4 lines
Quoted 1 line
kernel ;-)
Rather than sending messages, it's actually better to put them as *drafts*, ready to be sent by the user's normal mailer. It's not
hard
Quoted 4 lines
Quoted 4 lines
to do this — I usually dump the mails into ~/.local/share/evolution/mail/local/.Drafts/new/ for example.
And then I can *read* them before sending them, which is good
practice
Quoted 2 lines
Quoted 2 lines
anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting
'send'
Quoted 2 lines
Quoted 1 line
on an email?
Quoted 8 lines
Quoted 1 line
Certainly not, but what prevents you from doing that with
git-send-email ? In
Quoted 1 line
my workflow I always format patches with git-format-patch, proof-read
them
Quoted 2 lines
with my favourite $EDITOR and then use git-send-email to send them.
This exactly mateches my workflow (with an added 0000-Summary for patch series where needed).
Likewise though often with a prestep of a sanity check in gitk.
Quoted 5 lines
Guenter
_______________________________________________
Ksummit-discuss mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/ksummit-discuss
Signature · 1 line
Sent from my Android device with K-9 Mail. Please excuse my brevity.
Quoted 20 lines · Guenter
Hi Luis,
Quoted 7 lines · Luis R. Rodriguez
Quoted 6 lines
Quoted 1 line
Multiple S-o-b's don't always mean gaming, though. For example, my company's workflow requires me to sign off upstream patches, not to get annother S-o-b with my name on it, but to certify that the patch does not accidentially publish any company IP (and, if it does, it is my fault, not the fault of the person who wrote the code).
Quoted 10 lines
There is a danger to having people interpret the s-o-b tag differently than what it originally was intended for, such confusion deserves serious attention and my hope is that if folks detect these misuses they can try to educate folks on it. The s-o-b tag means the person is certifying under the Developer Certificate or Origin (DCO) the patch in question. That's it. The practical gains of such a leight weight development tool to use something like the s-o-b combined with the huge legal merit behind it has convinced us to generalize the DCO and encourage people outside of Linux to use it:
Quoted 2 lines
Not really sure if I understand you correctly. Are you saying that you consider the above to be a mis-use of s-o-b ?
Only if folks disregard or not aware of the DCO.
Quoted 3 lines
By co-signing a patch I do (co-)certify it under DCO; I am well aware of that. That it may have an additional context doesn't change that, or limit its value.
Sure.
Quoted 3 lines
I can well imagine that other companies have a
similar approval flow, and I don't really understand why that would or could be a problem. Can you educate me ?
The concern is when folks document SOB practices which do not address first and foremost that the SOB *is* primarily for the DCO, now if companies or groups like to have their own other internal ammendments for it, that's fine, its just that for patches that go into Linux the SOB just is meant to implicate the DCO. Nothing more.
Luis
Quoted 11 lines · Greg KH
Quoted 4 lines · Darren Hart
OK, all good points. It looks as though I can step up my own tooling some to make the email-to-compilation step faster so I don't spend as much time on patches with compiler warnings, that don't apply, etc. Dan C. said something similar.
I think I mentioned it before, but Wolfram has a set of scripts that does this really well. I don't know if they are published anywhere, but that would be a good place to start with. I think Sara Sharp also had a bunch that she used to make life easier, you might want to ask her the next time you see her in the office.
Will do. I think Jani sent me a set of scripts I need to review too.
Actually, in this sense, I'm the newbie maintainer who's spending time writing up scripts, tools, and mutt macros to handle a process that 970 other people have probably already written. I'll do so in a subtly different way of course, and this will add ever so slightly to the variation in expectations and behaviors of the Linux maintainers.
Maybe patchwork will be an improvement for tracking. Maybe not. While I do enjoy writing up these scripts and tools to automate my job as a maintainer.... my ability - or maybe willingness - to do so, shouldn't be what qualifies me for the job. More tooling that standardized the process and makes the code review more accessible to people less interested in writing mutt macros, might expand our pool of candidates.
Quoted 6 lines
Quoted 2 lines
The "one hour class" thing makes it sound like it takes "one hour" - but I find I have to revisit this stuff fairly regularly, and those hours add up.
Really? Why? Once you learn the workflow, what keeps changing that breaks things? External stuff (like corporate email servers), or things in our workflow/tools?
In my experience it's just more new people with the same questions. Once they're up and running, it's minimal effort to keep going. It's the initial ramp up that gets repeated. So it's not the "one hour" adding up for the newbie, it's that "one hour" adding up for me as the instructor :-) I'd love to help reduce the effort it takes to bring new people up (yup - totally selfish motivation here).
This is especially true when the new people don't stick around. I really don't want to invest an hour in someone that has 3 patches to send and will never return.
It can be more trying when someone is doing this for a job and not because they are interested in becoming a regular contributor. Each step is another barrier they'd just assume avoid. If they're new, they also don't understand the workflow or how maintainers scale, so they push against things that don't make sense for sending 1 patch - but are necessary for processing 1000. Many of these training sessions involve a certain amount of "why can't we just ..." or "you don't have gerrit setup?" or ... etc. Ultimately, it's just another barrier to recruitment.
We can say we don't want people like that contributing anyway, but the end result of that is less hardware supported, or even more burnt out senior Linux kernel developers who pick up the load because it's easier than training new people.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 7 lines · Dan Carpenter
Quoted 2 lines · Jan Kara
Quoted 1 line · Dan Carpenter
On Sun, Jul 12, 2015 at 07:28:23AM -0500, Josh Poimboeuf wrote:
This happened hours ago in staging. Someone sent a buggy patch and reviewers spotted the bug but no one got credit.
Quoted 7 lines
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072662.html
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072668.htmlImagine how special Patrick would feel if we gave him a nice "With-fix-from: Patrick Farrell <[email protected]>" tag. :) Also the other rule would be that only the first person to report the bug gets the credit (Sorry, Sudip).
Doesn't matter. I am a volunteer and contributing here is not part of my dayjob. I do it because I like doing it.
Quoted 3 lines
The next version of the patch had a process
problem which Sudip noticed as well but that still doesn't earn a with-fix-from tag.
Then will the first reviewer always get the credit? Suppose a hypothetial situation where v1 is just having a bug like the one you mentioned, reviewer X points that out so he gets "With-fix-from:", but v2 has a more serious problem and results in build failure and reviewer Y points that out and v3 is the final patch that is accepted. So now who will get "With-fix-from:" ?
regards
sudip
Quoted 15 lines · Damien Lespiau
Quoted 14 lines · Michael Ellerman
Quoted 12 lines · Daniel Vetter
Quoted 3 lines · Bjorn Helgaas
I wish I knew how to use patchwork better, or had a smarter workflow that could comprehend a series as a single entity. Patchwork is a lot of clicking, but I don't know anything better.
We're working on improving patchwork here to understand series and help out with auto-deprecating patches when new versions show up. Currently being tested internally and we plan to push to upstream ofc and deploy on freedesktop.org (since that's where all the drm/gfx folks hang out), but because of all the things going on it's really slow. Damien knows more, maybe we could push the current state to some git branch somewhere.
Quoted 8 lines
Quoted 4 lines
I'd be interested in that if you can publish it somewhere.
At the moment I have a very hacky script that tries to recognise a series on the client, which usually works, but not always.
I have quite a few patches on top of upstream now. It's really a back burner distraction, so well, I have no ETA to give for when I'd be happy with the state of this work.
Yeah fair enough, I'm in the same boat, it's a tool I use for my job but it's not my job to work on the tool :)
Quoted 7 lines
I have a work-in-progress branch here:
https://github.com/dlespiau/patchwork
What's on there is roughly a re-design of the interface, a new REST API and parsing/presenting series to the user, not just patches.
Quoted 8 lines
I have some more work (unpublished because not quite ready) on top of this to parse and present new versions/revisions of series when:
- people post a v2/3/4/... of a patch as a reply to one of the series
- people post a full new series as a v2/3/4/..The goal being one series object (with a unique ID for that patchwork instance) represents the whole life cycle of that work, including multiple versions.
Sounds great.
Maybe we can slowly get some of it merged, I'll try and have a look at it in my copious spare time.
cheers
Quoted 23 lines · Sudip Mukherjee
Quoted 8 lines · Dan Carpenter
Quoted 2 lines · Jan Kara
Quoted 1 line · Dan Carpenter
On Sun, Jul 12, 2015 at 07:28:23AM -0500, Josh Poimboeuf wrote:
This happened hours ago in staging. Someone sent a buggy patch and reviewers spotted the bug but no one got credit.
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072662.html
Quoted 1 line
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072668.html
Quoted 3 lines
Imagine how special Patrick would feel if we gave him a nice "With-fix-from: Patrick Farrell <[email protected]>" tag. :) Also the
other
Quoted 2 lines
rule would be that only the first person to report the bug gets the credit (Sorry, Sudip).
Doesn't matter. I am a volunteer and contributing here is not part of my dayjob. I do it because I like doing it.
Quoted 3 lines
The next version of the patch had a process
problem which Sudip noticed as well but that still doesn't earn a with-fix-from tag.
Quoted 9 lines
Then will the first reviewer always get the credit? Suppose a hypothetial
situation where v1 is just having a bug like the one you mentioned, reviewer X points that out so he gets "With-fix-from:", but v2 has a more
serious problem and results in build failure and reviewer Y points that out
and v3 is the final patch that is accepted. So now who will get "With-fix-from:" ?
Both surely. Different bug, different tag (though only one per bug finder)
Quoted 3 lines
regards
sudip
Signature · 1 line
Sent from my Android device with K-9 Mail. Please excuse my brevity.
Quoted 9 lines · Sudip Mukherjee
Quoted 3 lines
The next version of the patch had a process
problem which Sudip noticed as well but that still doesn't earn a with-fix-from tag.Then will the first reviewer always get the credit? Suppose a hypothetial situation where v1 is just having a bug like the one you mentioned, reviewer X points that out so he gets "With-fix-from:", but v2 has a more serious problem and results in build failure and reviewer Y points that out and v3 is the final patch that is accepted. So now who will get "With-fix-from:" ?
No no. Build fixes don't count... Only runtime bugs. But, yes, if there are two bugs you give credit for both.
regards,
dan carpenter
Quoted 2 lines · Michael Ellerman
Maybe we can slowly get some of it merged, I'll try and have a look at it in my copious spare time.
I did give it a go with a first batch[1] and Jeremy sounded open to the ideas and came back with a few comments. After that, it's all a big blur with actual work taking over.
I do hope to go back at it soon-ish, it's becoming increasingly important for the i915 driver and mesa (talking about the the patchwork instance on freedeskop.org).
Signature · 3 lines
Damien [1] https://lists.ozlabs.org/pipermail/patchwork/2014-November/001148.html
Quoted 20 lines · Sudip Mukherjee
Quoted 7 lines · Dan Carpenter
Quoted 2 lines · Jan Kara
Quoted 1 line · Dan Carpenter
On Sun, Jul 12, 2015 at 07:28:23AM -0500, Josh Poimboeuf wrote:
This happened hours ago in staging. Someone sent a buggy patch and reviewers spotted the bug but no one got credit.
Quoted 7 lines
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072662.html
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072668.htmlImagine how special Patrick would feel if we gave him a nice "With-fix-from: Patrick Farrell <[email protected]>" tag. :) Also the other rule would be that only the first person to report the bug gets the credit (Sorry, Sudip).
Doesn't matter. I am a volunteer and contributing here is not part of my dayjob. I do it because I like doing it.
Quoted 3 lines
The next version of the patch had a process
problem which Sudip noticed as well but that still doesn't earn a with-fix-from tag.
Quoted 6 lines
Then will the first reviewer always get the credit? Suppose a hypothetial situation where v1 is just having a bug like the one you mentioned, reviewer X points that out so he gets "With-fix-from:", but v2 has a more serious problem and results in build failure and reviewer Y points that out and v3 is the final patch that is accepted. So now who will get "With-fix-from:" ?
Or even more important, how in the world will the maintainer be adding these tags in a simple manner? It's a manual thing for me to do today, which is a pain, and given that I have no "state" of previous patches remembering what happened in previous versions, I don't know how I would be expected to keep track of all of this.
So whatever scheme people come up with, please remember that it has to be easy to actually implement...
thanks,
greg k-h
Quoted 7 lines · Laurent Pinchart
Quoted 5 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Certainly not, but what prevents you from doing that with git-send-email ?
I don't know. It's not that I *can't* do that with git-send-email.
But I seem to see things differently when it's in a mail compose window, and I *do* spot trivial issues there, that I've missed when actually editing the code and even reviewing patches in gitk/etc.
Perhaps it's just the additional mental stimulus of physically preparing to hit the 'send' button and send it out to the world with my name on it.
Perhaps I'm just a bit weird.
-- dwmw2
Quoted 28 lines · Greg KH
Quoted 20 lines · Sudip Mukherjee
Quoted 7 lines · Dan Carpenter
Quoted 2 lines · Jan Kara
Quoted 1 line · Dan Carpenter
On Sun, Jul 12, 2015 at 07:28:23AM -0500, Josh Poimboeuf wrote:
This happened hours ago in staging. Someone sent a buggy patch and reviewers spotted the bug but no one got credit.
Quoted 7 lines
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072662.html
http://driverdev.linuxdriverproject.org/pipermail/driverdev-devel/2015-July/072668.htmlImagine how special Patrick would feel if we gave him a nice "With-fix-from: Patrick Farrell <[email protected]>" tag. :) Also the other rule would be that only the first person to report the bug gets the credit (Sorry, Sudip).
Doesn't matter. I am a volunteer and contributing here is not part of my dayjob. I do it because I like doing it.
Quoted 3 lines
The next version of the patch had a process
problem which Sudip noticed as well but that still doesn't earn a with-fix-from tag.Quoted 6 lines
Then will the first reviewer always get the credit? Suppose a hypothetial situation where v1 is just having a bug like the one you mentioned, reviewer X points that out so he gets "With-fix-from:", but v2 has a more serious problem and results in build failure and reviewer Y points that out and v3 is the final patch that is accepted. So now who will get "With-fix-from:" ?
Quoted 8 lines
Or even more important, how in the world will the maintainer be adding these tags in a simple manner? It's a manual thing for me to do today, which is a pain, and given that I have no "state" of previous patches remembering what happened in previous versions, I don't know how I would be expected to keep track of all of this.
So whatever scheme people come up with, please remember that it has to be easy to actually implement...
I think it would need to be up to the patch author, not the maintainer, to add the tag. The patch author already tracks the patch state from version to version. And the author is in the best position to know which comments are helpful.
Also I'd suggest something a little broader than "With-fix-from". Not all useful comments are "fixes". For example, an insightful question or comment can sometimes result in big changes in the next version of the patch.
Signature · 1 line
Josh
Quoted 7 lines · David Woodhouse
Quoted 6 lines · Laurent Pinchart
Quoted 5 lines
And then I can *read* them before sending them, which is good practice anyway. Am I the only person who often finds a final minor nit with their own patch, in that final read-through just before hitting 'send' on an email?
Quoted 7 lines
Quoted 1 line
Certainly not, but what prevents you from doing that with git-send-email ?
I don't know. It's not that I *can't* do that with git-send-email.
But I seem to see things differently when it's in a mail compose window, and I *do* spot trivial issues there, that I've missed when actually editing the code and even reviewing patches in gitk/etc.
I agree. There's something different about viewing a patch in the mail client vs in an editor or pager.
Quoted 3 lines
Perhaps it's just the additional mental stimulus of physically preparing to hit the 'send' button and send it out to the world with my name on it.
It could also be that we're conditioned to reviewing patches in the mail client. So seeing the patch there triggers review-mode vice write-mode.
But I also think there's something about the review process prior to 'send' that catches mistakes as well.
thx,
Jason.
Quoted 8 lines · Greg KH
Or even more important, how in the world will the maintainer be adding these tags in a simple manner? It's a manual thing for me to do today, which is a pain, and given that I have no "state" of previous patches remembering what happened in previous versions, I don't know how I would be expected to keep track of all of this.
So whatever scheme people come up with, please remember that it has to be easy to actually implement...
It's like Reported-by: the patch sender adds it when they write the patch (re-write it in this case).
regards,
dan carpenter
Quoted 4 lines · Josh Poimboeuf
Also I'd suggest something a little broader than "With-fix-from". Not all useful comments are "fixes". For example, an insightful question or comment can sometimes result in big changes in the next version of the patch.
I wouldn't want it to be too broad. Sending complaints about style issues is its own reward. Painting the woodshed etc.
regards,
dan carpenter
Quoted 14 lines · Peter Hüwe
Am Samstag, 11. Juli 2015, 17:04:37 schrieb Greg KH:
Quoted 11 lines · Darren Hart
Quoted 4 lines
OK, all good points. It looks as though I can step up my own tooling some to make the email-to-compilation step faster so I don't spend as much time on patches with compiler warnings, that don't apply, etc. Dan C. said something similar.
I think I mentioned it before, but Wolfram has a set of scripts that does this really well. I don't know if they are published anywhere, but that would be a good place to start with. I think Sara Sharp also had a bunch that she used to make life easier, you might want to ask her the next time you see her in the office.
Quoted 5 lines
They are called ninja-check and published here
https://lists.linuxfoundation.org/pipermail/ksummit-discuss/2014-May/000554.htmlKsummit Thread about all these tools can be found here:
ftp://kernel.mirrors.pair.com/pub/linux/kernel/people/paulmck/LKS/LKS2014Topic/000291.html
Thank you all very much for these pointers. I have ninja-check up and running all the checkers now. Between these and:
http://www.do-not-panic.com/2014/07/applying-patches-from-mutt-onto-git.html
(view source for actual .muttrc as his blog hides <pipe-entry> and <tag-prefix>)
And Ben's original:
http://flavioleitner.blogspot.com/2011/03/patch-workflow-with-mutt-and-git.html
I added a checkpatch binding as well.
I now have a much more capable mutt-to-git interface which should help a ton. It took me a day while dodging everything else I could, and I'll continue to tweak it forever of course. Well worth the effort.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 4 lines · On Sat, 11 Jul 2015 11:24:41 +0530 Sudip Mukherjee…
Another problem, when a newbie tries to move out of staging to some other subsystem he likes, the maintainer may not be that much responsive. Just for example, i submitted a patch on November, 2014 and I am yet to receive a reply or review to that and the patch was not a style correction patch.
BTW, it should always be OK to ping the maintainer if they ignore a patch. I believe one week is a good time to wait. And again in another week if they still do not reply. I know a few maintainers that think if they get to a patch that is old and the author never pinged them, they think the author doesn't think that patch is too important and they just delete it.
I know I've been bad when patches are sent to me, especially if I'm traveling and I don't have access to a real computer (read the patch on my phone). I'll mark it with 'todo' and go on. By the time I get home, I have 10 or 20 emails marked 'todo' and I could spend days on a few of them before continuing. Finally, they just get buried, and lost in the abyss of my INBOX. I never delete them, and after my inbox gets too big, I'll actually try to purge it from oldest to newest, and I have replied to patches that were over a year old, and even applied them!
I tell everyone, that if they do not hear from me within a week, please send me a 'ping'. It will put that patch higher in the 'todo' stack.
I'm sure all maintainers are fine with a friendly ping after a week. Don't send a ping before then, because maintainers are busy, and may get annoyed by being too pushy.
-- Steve
Quoted 11 lines · Laurent Pinchart
The first topic we're trying to address is recruitment. From that point of view, giving as much feedback as possible to newcomers is good as long as we can make the automatic feedback constructive. An automated reply along the lines of
"You have tried to send a patch through e-mail to the [email protected] mailing list. We have detected that your e-mail includes HTML content. This is not allowed for the reasons explained at [...]. Please configure your e-mail client to send plain text only and resend the patch. Instructions on how to do so far popular e-mail clients can be found at [...]"
Yeah, at the moment I believe 'unacceptable' mail to vger lists just gets black-holed. Leaving users wondering WTF they did wrong. Or just wondering why they didn't get any responses.
It would be much nicer to do the same tests at SMTP time, giving the rejection immediately.
Signature · 1 line
dwmw2
Quoted 13 lines · David Woodhouse
Quoted 11 lines · Laurent Pinchart
The first topic we're trying to address is recruitment. From that point of view, giving as much feedback as possible to newcomers is good as long as we can make the automatic feedback constructive. An automated reply along the lines of
"You have tried to send a patch through e-mail to the [email protected] mailing list. We have detected that your e-mail includes HTML content. This is not allowed for the reasons explained at [...]. Please configure your e-mail client to send plain text only and resend the patch. Instructions on how to do so far popular e-mail clients can be found at [...]"
Quoted 6 lines
Yeah, at the moment I believe 'unacceptable' mail to vger lists just gets black-holed. Leaving users wondering WTF they did wrong. Or just wondering why they didn't get any responses.
It would be much nicer to do the same tests at SMTP time, giving the rejection immediately.
I'll let DaveM speak for himself on vger, but the reason I don't do this type of thing at SMTP time is that it holds the connections open and you can easily swamp the system. If you queue the scans, you have a much tighter control on your machine load (admittedly my "cloud" system is still a single processor i586 so I might be slightly behind the technology curve).
James
Am 16. Juli 2015 11:21:37 MESZ, schrieb David Woodhouse <[email protected]>:
Quoted 15 lines · Laurent Pinchart
Quoted 2 lines
The first topic we're trying to address is recruitment. From that
point of
Quoted 1 line
view, giving as much feedback as possible to newcomers is good as
long as we
Quoted 1 line
can make the automatic feedback constructive. An automated reply
along the
Quoted 3 lines
lines of
"You have tried to send a patch through e-mail to the [email protected]
mailing list.
Quoted 1 line
We have detected that your e-mail includes HTML content. This is not
allowed
Quoted 1 line
for the reasons explained at [...]. Please configure your e-mail
Quoted 9 lines
client to
Quoted 1 line
send plain text only and resend the patch. Instructions on how to do
so far
Quoted 1 line
popular e-mail clients can be found at [...]"
Yeah, at the moment I believe 'unacceptable' mail to vger lists just gets black-holed. Leaving users wondering WTF they did wrong. Or just wondering why they didn't get any responses.
I don't think so, at least when I got my new phone and was replying to some mails I did get some "you are sending HTML spam" message back. ( as HTML used to be the default setting :/ )
Peter
Signature · 1 line
Sent from my mobile
Quoted 7 lines · James Bottomley
Quoted 6 lines
Yeah, at the moment I believe 'unacceptable' mail to vger lists just gets black-holed. Leaving users wondering WTF they did wrong. Or just wondering why they didn't get any responses.
It would be much nicer to do the same tests at SMTP time, giving the rejection immediately.
Quoted 6 lines
I'll let DaveM speak for himself on vger, but the reason I don't do this type of thing at SMTP time is that it holds the connections open and you can easily swamp the system. If you queue the scans, you have a much tighter control on your machine load (admittedly my "cloud" system is still a single processor i586 so I might be slightly behind the technology curve).
It's no *additional* work; the scanning was being done anyway. Yes, it means you keep a TCP socket open while you do the scan. But that really shouldn't be a big resource issue.
If the machine is overloaded, it can stop taking incoming connections or it can slow them down. Both of which will happen naturally. The overall result will be that there's a slight delay, and it accepts the mail later instead. Which is basically the same as if the message is queued and processed later.
Besides, I believe most of the scans we're talking about¹ are simple regex stuff and just shouldn't take that long anyway. Although many people *do* run things like CRM114/ClamAV/SpamAssassin a SMTP time, even on i586-class machines.
Signature · 2 lines
dwmw2 ¹ http://vger.kernel.org/majordomo-taboos.txt
Quoted 7 lines · Steven Rostedt
Quoted 4 lines · Sudip Mukherjee
Another problem, when a newbie tries to move out of staging to some other subsystem he likes, the maintainer may not be that much responsive. Just for example, i submitted a patch on November, 2014 and I am yet to receive a reply or review to that and the patch was not a style correction patch.
Quoted 6 lines
BTW, it should always be OK to ping the maintainer if they ignore a patch. I believe one week is a good time to wait. And again in another week if they still do not reply. I know a few maintainers that think if they get to a patch that is old and the author never pinged them, they think the author doesn't think that patch is too important and they just delete it.
Please don't encourage people to send content free pings bit instead resend it - a content free ping mostly just adds to mail volume which is pretty much the original problem. If the patch has actually been lost then a resend is going to be needed anyway and if not then it's mostly just adding to mail volume. With a lot of mail clients (including mutt which I use) the nag will get threaded in with the original patch buried back in the mailbox and not even be seen if that's still sitting waiting for handling.
Quoted 3 lines
I'm sure all maintainers are fine with a friendly ping after a week. Don't send a ping before then, because maintainers are busy, and may get annoyed by being too pushy.
Not me, they tend to just annoy me for the reasons above. Resends are useful but just straight up pings not so much.
I'd say a couple of weeks is a better lower limit than a single week unless it's a very serious bugfix, a week could easily be a holiday or whatever and larger patches or patch serieses do take time to review.
Quoted 15 lines · On Thu, 16 Jul 2015 14:25:51 +0100 Mark Brown <[email protected]> wrote:
Quoted 7 lines · Steven Rostedt
Quoted 4 lines · Sudip Mukherjee
Another problem, when a newbie tries to move out of staging to some other subsystem he likes, the maintainer may not be that much responsive. Just for example, i submitted a patch on November, 2014 and I am yet to receive a reply or review to that and the patch was not a style correction patch.
Quoted 6 lines
BTW, it should always be OK to ping the maintainer if they ignore a patch. I believe one week is a good time to wait. And again in another week if they still do not reply. I know a few maintainers that think if they get to a patch that is old and the author never pinged them, they think the author doesn't think that patch is too important and they just delete it.
Quoted 8 lines
Please don't encourage people to send content free pings bit instead resend it - a content free ping mostly just adds to mail volume which is pretty much the original problem. If the patch has actually been lost then a resend is going to be needed anyway and if not then it's mostly just adding to mail volume. With a lot of mail clients (including mutt which I use) the nag will get threaded in with the original patch buried back in the mailbox and not even be seen if that's still sitting waiting for handling.
Well, then to each their own. I prefer the content free ping, because in my mail client (claws), it brings the original patch up to the front (my threading is to sort by latest email in the thread). A simple ping will move their patch ahead of other patches that may have been sent later, but are still in the abyss.
A resend will just be a duplicate in my inbox and it will confuse me about why I have more than one of the same patch.
Quoted 7 lines
Quoted 4 lines
I'm sure all maintainers are fine with a friendly ping after a week. Don't send a ping before then, because maintainers are busy, and may get annoyed by being too pushy.
Not me, they tend to just annoy me for the reasons above. Resends are useful but just straight up pings not so much.
Then a simple reply to that content-free ping to tell the author what you prefer. In fact, that's what I do when they ask me about it. I sometimes even try to send a reply when I get the original patch (privately to the author from my phone) that tells them to ping me in a week if they don't hear back from me.
Quoted 4 lines
I'd say a couple of weeks is a better lower limit than a single week unless it's a very serious bugfix, a week could easily be a holiday or whatever and larger patches or patch serieses do take time to review.
The time length varies from person to person. Just let the author know what you prefer. From developers I've talked to (including myself), a week seems to be the norm to wait. Anything less is an annoyance.
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
-- Steve
Quoted 4 lines · Steven Rostedt
Quoted 1 line · On Thu, 16 Jul 2015 14:25:51 +0100 Mark Brown <[email protected]> wrote:
On Wed, Jul 15, 2015 at 09:20:43PM -0400, Steven Rostedt wrote:
Quoted 8 lines
Quoted 2 lines
Quoted 1 line
Sudip Mukherjee <[email protected]> wrote:
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
Then in my opinion, it will be better if every maintainer has a script which will reply automatically on receiving a patch that if the patch is not applied within xxx days then please send a ping / resend the patch.
regards
sudip
Quoted 5 lines · Steven Rostedt
Well, then to each their own. I prefer the content free ping, because in my mail client (claws), it brings the original patch up to the front (my threading is to sort by latest email in the thread). A simple ping will move their patch ahead of other patches that may have been sent later, but are still in the abyss.
Interesting, not noticed a mail client with that sorting scheme before.
Quoted 2 lines
A resend will just be a duplicate in my inbox and it will confuse me about why I have more than one of the same patch.
That happens often enough anyway due to people sending new versions in response to other review comments or similar so I find I need to cope with discarding old copies of things anyway.
Quoted 8 lines
Quoted 2 lines
Not me, they tend to just annoy me for the reasons above. Resends are useful but just straight up pings not so much.
Then a simple reply to that content-free ping to tell the author what you prefer. In fact, that's what I do when they ask me about it. I sometimes even try to send a reply when I get the original patch (privately to the author from my phone) that tells them to ping me in a week if they don't hear back from me.
That's what I do (or just ignore them if I already have the patch) but it does get rather repetitive and adds to the mail volume which is part of the problem.
The basic reason I advise people to resend is that if a maintainer has a resend in their inbox they should have everything they need to handle the patch then and there, there are fewer things that can go wrong with that than with a content free ping.
Quoted 8 lines
Quoted 3 lines
I'd say a couple of weeks is a better lower limit than a single week unless it's a very serious bugfix, a week could easily be a holiday or whatever and larger patches or patch serieses do take time to review.
The time length varies from person to person. Just let the author know what you prefer. From developers I've talked to (including myself), a week seems to be the norm to wait. Anything less is an annoyance.
Less than a week is of course far too fast, it's a good way to get ignored. On the other hand a week definitely does seem to too fast to be telling people to use as a starting point, my own experience submitting patches and watching other people submitting patches is that a week is definitely not an unusual time to have to wait for non-urgent things to get handled, I only tend to start worrying that things might've been missed after a couple of weeks.
Quoted 6 lines
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
I basically agree with that, what I'm saying on the response time is that I don't think you're setting realistic baselines for people. A week is just not what's actually happening in large parts of the kernel. There are some people I'd expect to respond within a week in the normal course of affairs but there are more where I wouldn't worry about it and even the more responsive people are often slower on larger changes like new driver submissions.
Quoted 9 lines · Mark Brown
Quoted 5 lines · Steven Rostedt
Well, then to each their own. I prefer the content free ping, because in my mail client (claws), it brings the original patch up to the front (my threading is to sort by latest email in the thread). A simple ping will move their patch ahead of other patches that may have been sent later, but are still in the abyss.
Interesting, not noticed a mail client with that sorting scheme before.
I thought all mail clients can do this ... evolution certainly does and I use it and imap labels to create lists of patches ready for applying.
However, there is an unintended consequence: If I'm working from this list and applying patches in the order the mail client is presenting them, any patch which receives a reply gets dragged to the bottom of my list. Usually this is correct because it means there's still debate about the patch, but if you're going to send me pings as replies, they have the same effect and delay the testing and application of the patch.
James
Quoted 10 lines · On Thu, 16 Jul 2015 15:41:55 +0100 Mark Brown <[email protected]> wrote:
Quoted 5 lines · Steven Rostedt
Well, then to each their own. I prefer the content free ping, because in my mail client (claws), it brings the original patch up to the front (my threading is to sort by latest email in the thread). A simple ping will move their patch ahead of other patches that may have been sent later, but are still in the abyss.
Interesting, not noticed a mail client with that sorting scheme before.
Both claws and evolution do this. I believe it's default for evolution, and I kind of remember having to select this sorting style with claws.
Quoted 6 lines
Quoted 2 lines
A resend will just be a duplicate in my inbox and it will confuse me about why I have more than one of the same patch.
That happens often enough anyway due to people sending new versions in response to other review comments or similar so I find I need to cope with discarding old copies of things anyway.
Oh, I expect a new version. Usually they are marked with v2, and that lets me know to ignore the old one.
Quoted 7 lines
Quoted 6 lines
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
Quoted 7 lines
I basically agree with that, what I'm saying on the response time is that I don't think you're setting realistic baselines for people. A week is just not what's actually happening in large parts of the kernel. There are some people I'd expect to respond within a week in the normal course of affairs but there are more where I wouldn't worry about it and even the more responsive people are often slower on larger changes like new driver submissions.
And a lot of what maintainers prefer has to deal with the types of changes they handle. I don't handle new devices. I usually handle new features for tracing or bug fixes. Sometimes its updates for different archs.
I especially prefer the ping if its for a patch series, as sending out a new patch series that didn't change anything will definitely waste my time, as I usually compare the old with the new to see what changed.
-- Steve
Quoted 3 lines · Sudip Mukherjee
Then in my opinion, it will be better if every maintainer has a script which will reply automatically on receiving a patch that if the patch is not applied within xxx days then please send a ping / resend the patch.
That then sets the expectation that you're going to do something with the patch which is fine if it's relevant but there's lots of moderately common cases with things like changes that touch multiple subsystems (eg, for mfds or for adding a device driver and the DT using it simultaneously) which result in things like resends of patches that you've already reviewed due to a change earlier in the series and which could get awfully noisy and/or confusing for submitters as a result.
To be reliable you'd off the top of my head need to start doing things like parsing the patch to make sure it was for a relevant subsystem and that it hadn't already got a reviewed/acked/whatever tag, sending a different message if it wasn't something you'd expect to handle yourself. Personally I don't know that I trust my skills in appropriate scripting languages to write that safely.
Quoted 5 lines · Steven Rostedt
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
I agree with this completely. When you switch systems (which I've done something like 5 times in the last 2 years), you are essentially a newbie in that new system.
How about putting some notes in the MAINTAINER file for things like this, that some get_maintainer.pl option could show?
We could use a I: prefix, for "Instructions:" (only because 'N:' is already used.)
I'm not sure the what types of per-maintainer differences would be good to list, but at least the two described here would be good:
- ping delay preference
- ping style (whole patch or just an alert) preference
I think there may be some other things that we could recommend, but maybe it would be good to use free-form instructions for a while and see what patterns emerge.
A side benefit of this would be that maintainers could see what their colleagues are doing, which might help spread knowledge of useful practices.
-- Tim
Quoted 9 lines · James Bottomley
Quoted 7 lines · Mark Brown
Quoted 5 lines · Steven Rostedt
Well, then to each their own. I prefer the content free ping, because in my mail client (claws), it brings the original patch up to the front (my threading is to sort by latest email in the thread). A simple ping will move their patch ahead of other patches that may have been sent later, but are still in the abyss.
Quoted 4 lines
Quoted 1 line
Interesting, not noticed a mail client with that sorting scheme before.
I thought all mail clients can do this ... evolution certainly does and I use it and imap labels to create lists of patches ready for applying.
Hrm, perhaps it's more common in graphical clients than text mode ones - I have to confess I've never really got on with graphical clients for kernel workflow and everything else I'm much more inbox 0. I mostly use mutt but I do try others from time to time.
Quoted 6 lines
However, there is an unintended consequence: If I'm working from this list and applying patches in the order the mail client is presenting them, any patch which receives a reply gets dragged to the bottom of my list. Usually this is correct because it means there's still debate about the patch, but if you're going to send me pings as replies, they have the same effect and delay the testing and application of the patch.
Heh.
Quoted 10 lines · Steven Rostedt
Quoted 7 lines · Mark Brown
I basically agree with that, what I'm saying on the response time is that I don't think you're setting realistic baselines for people. A week is just not what's actually happening in large parts of the kernel. There are some people I'd expect to respond within a week in the normal course of affairs but there are more where I wouldn't worry about it and even the more responsive people are often slower on larger changes like new driver submissions.
Quoted 4 lines
And a lot of what maintainers prefer has to deal with the types of changes they handle. I don't handle new devices. I usually handle new features for tracing or bug fixes. Sometimes its updates for different archs.
Sure, though there's also a large amount of people's work patterns as well - a lot of maintainers seem to batch up their work, sit down and blast through a lot of changes at once.
Quoted 3 lines
I especially prefer the ping if its for a patch series, as sending out a new patch series that didn't change anything will definitely waste my time, as I usually compare the old with the new to see what changed.
Oh, I tend to do the same thing but I basically just discard anything I didn't review yet and compare against the baseline - if it's a resend then I'm not discarding anything, if it's been improved then I get to skip reviewing the intermediate version.
Quoted 1 line · On Thu, 16 Jul 2015 17:12:51 +0200 Ralf Baechle <[email protected]> wrote:
Haven't systems like patchwork mostly obsoleted ping emails?
Not for small subsystems that don't use patchwork (like tracing).
-- Steve
Quoted 4 lines · Mark Brown
Hrm, perhaps it's more common in graphical clients than text mode ones - I have to confess I've never really got on with graphical clients for kernel workflow and everything else I'm much more inbox 0. I mostly use mutt but I do try others from time to time.
You can achieve the same by setting "sort_aux" properly in mutt. pine can do that as well (thread-sorts-by-arrival setting).
Signature · 2 lines
Jiri Kosina SUSE Labs
Quoted 21 lines · Tim Bird
Quoted 5 lines · Steven Rostedt
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
I agree with this completely. When you switch systems (which I've done something like 5 times in the last 2 years), you are essentially a newbie in that new system.
How about putting some notes in the MAINTAINER file for things like this, that some get_maintainer.pl option could show?
We could use a I: prefix, for "Instructions:" (only because 'N:' is already used.)I'm not sure the what types of per-maintainer differences would be good to list, but at least the two described here would be good:
- ping delay preference
- ping style (whole patch or just an alert) preference
Quoted 7 lines
I think there may be some other things that we could recommend, but maybe it would be good to use free-form instructions for a while and see what patterns emerge.
A side benefit of this would be that maintainers could see what their colleagues are doing, which might help spread knowledge of useful practices.
Haven't systems like patchwork mostly obsoleted ping emails?
Ralf
Quoted 27 lines · Ralf Baechle
Quoted 25 lines · Tim Bird
Quoted 5 lines · Steven Rostedt
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
I agree with this completely. When you switch systems (which I've done something like 5 times in the last 2 years), you are essentially a newbie in that new system.
How about putting some notes in the MAINTAINER file for things like this, that some get_maintainer.pl option could show?
We could use a I: prefix, for "Instructions:" (only because 'N:' is already used.)I'm not sure the what types of per-maintainer differences would be good to list, but at least the two described here would be good:
- ping delay preference
- ping style (whole patch or just an alert) preferenceI think there may be some other things that we could recommend, but maybe it would be good to use free-form instructions for a while and see what patterns emerge.
Quoted 5 lines
Quoted 3 lines
A side benefit of this would be that maintainers could see what their colleagues are doing, which might help spread knowledge of useful practices.
Haven't systems like patchwork mostly obsoleted ping emails?
$ grep ^[A-Z][^:] MAINTAINERS | wc -l 1389 $ grep ^Q: MAINTAINERS | wc -l 102
I think it's safe to say that less than 10% of sub-systems use patchwork (or at least are documented to use patchwork).
-- Tim
Quoted 7 lines · On Thu, 16 Jul 2015 08:04:30 -0700 Tim Bird <[email protected]> wrote:
Quoted 5 lines · Steven Rostedt
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
Quoted 8 lines
I agree with this completely. When you switch systems (which I've done something like 5 times in the last 2 years), you are essentially a newbie in that new system.
How about putting some notes in the MAINTAINER file for things like this, that some get_maintainer.pl option could show?
We could use a I: prefix, for "Instructions:" (only because 'N:' is already used.)
So somebody has to play the devil's advocate and ask this question... Are we really better off documenting the fact that what looks like a single project is actually a collection of a hundred or so idiosyncratic fiefdoms with their own contact protocols, coding styles, beer preferences, and more? Or perhaps we might think about gravitating toward a more uniform set of conventions? Preferably the ones I use? :)
Seriously, this area is a minefield for new developers; it can be discouraging to put together your first patch, carefully follow everything found in SubmittingPatches, CodingStyle, SubmitChecklist, and HOWTO, appease the checkpatch.pl beast, carefully run get_maintainer.pl with the correct command-line options, and follow all the suggestions provided by reddit, Phoronix and 4chan, only to be told that the patch came in during the wrong phase of the moon and they really should have known better.
Not sure what the real answer is, but something tells me that adding a new domain-specific language to MAINTAINERS isn't quite it :)
jon
Quoted 3 lines · On Thu, 16 Jul 2015 09:41:25 -0600 Jonathan Corbet <[email protected]> wrote:
Not sure what the real answer is, but something tells me that adding a new domain-specific language to
MAINTAINERSisn't quite it :)
I agree. I believe it really comes down to the maintainers, when they receive a patch, to express things NICELY to the new developer on any changes they may need to make. And even say, that it's the maintainer's preference and may not be something everyone else does.
It all comes down to the delivery of that notice. If you are nice and polite, and say "thank you for your patch", it may not be such a burden for the new developer. But if you come across as "Don't do it that way, you need to do it this way", it may be a big time turn off.
-- Steve
Quoted 26 lines · Jonathan Corbet
Quoted 7 lines · On Thu, 16 Jul 2015 08:04:30 -0700 Tim Bird <[email protected]> wrote:
Quoted 5 lines · Steven Rostedt
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
Quoted 8 lines
I agree with this completely. When you switch systems (which I've done something like 5 times in the last 2 years), you are essentially a newbie in that new system.
How about putting some notes in the MAINTAINER file for things like this, that some get_maintainer.pl option could show?
We could use a I: prefix, for "Instructions:" (only because 'N:' is already used.)So somebody has to play the devil's advocate and ask this question... Are we really better off documenting the fact that what looks like a single project is actually a collection of a hundred or so idiosyncratic fiefdoms with their own contact protocols, coding styles, beer preferences, and more? Or perhaps we might think about gravitating toward a more uniform set of conventions? Preferably the ones I use? :)
Quoted 8 lines
Seriously, this area is a minefield for new developers; it can be discouraging to put together your first patch, carefully follow everything found in SubmittingPatches, CodingStyle, SubmitChecklist, and HOWTO, appease the checkpatch.pl beast, carefully run get_maintainer.pl with the correct command-line options, and follow all the suggestions provided by reddit, Phoronix and 4chan, only to be told that the patch came in during the wrong phase of the moon and they really should have known better.
Indeed.
Quoted 2 lines
Not sure what the real answer is, but something tells me that adding a new domain-specific language to
MAINTAINERSisn't quite it :)
Not to rain on my own idea, but I strenuously agree. I think one of the reasons the SubmittingPatches files is not exhaustive is that there are too many differences between maintainers for some things, and some things change, even for a single maintainer, given the type of patch and current maintainer circumstances. Adding to MAINTAINERS doesn't address this last variability at all.
We've been loathe to try to enforce consistency of process for maintainers, thinking it would harm maintainer productivity (and it well might). But it makes automation hard, and you do end up with newbies facing these daunting 110-step processes, which still omit important steps, and might be contradictory for cross-system submissions.
-- Tim
Quoted 19 lines · Jonathan Corbet
Quoted 7 lines · On Thu, 16 Jul 2015 08:04:30 -0700 Tim Bird <[email protected]> wrote:
Quoted 5 lines · Steven Rostedt
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
Quoted 8 lines
I agree with this completely. When you switch systems (which I've done something like 5 times in the last 2 years), you are essentially a newbie in that new system.
How about putting some notes in the MAINTAINER file for things like this, that some get_maintainer.pl option could show?
We could use a I: prefix, for "Instructions:" (only because 'N:' is already used.)
Quoted 6 lines
So somebody has to play the devil's advocate and ask this question... Are we really better off documenting the fact that what looks like a single project is actually a collection of a hundred or so idiosyncratic fiefdoms with their own contact protocols, coding styles, beer preferences, and more? Or perhaps we might think about gravitating toward a more uniform set of conventions? Preferably the ones I use? :)
Agreed completely. We already maintain a uniform set of coding style conventions (with only one notable exception in net/) and one uniform set of patch guidelines ("the perfect patch", as implemented by git format-patch). It's not unreasonable to maintain a uniform set of maintenance procedures as well.
- Josh Triplett
Quoted 35 lines · Jonathan Corbet
Quoted 7 lines · On Thu, 16 Jul 2015 08:04:30 -0700 Tim Bird <[email protected]> wrote:
Quoted 5 lines · Steven Rostedt
One of the issues with newcomers coming to development of the Linux kernel, is that every maintainer is different. We should be trying harder to let people know what we prefer. Every maintainer expects something different, but it's up to the maintainer to explicitly let others know what they want. You can't expect everyone to read your mind.
Quoted 8 lines
I agree with this completely. When you switch systems (which I've done something like 5 times in the last 2 years), you are essentially a newbie in that new system.
How about putting some notes in the MAINTAINER file for things like this, that some get_maintainer.pl option could show?
We could use a I: prefix, for "Instructions:" (only because 'N:' is already used.)So somebody has to play the devil's advocate and ask this question... Are we really better off documenting the fact that what looks like a single project is actually a collection of a hundred or so idiosyncratic fiefdoms with their own contact protocols, coding styles, beer preferences, and more? Or perhaps we might think about gravitating toward a more uniform set of conventions? Preferably the ones I use? :)
Seriously, this area is a minefield for new developers; it can be discouraging to put together your first patch, carefully follow everything found in SubmittingPatches, CodingStyle, SubmitChecklist, and HOWTO, appease the checkpatch.pl beast, carefully run get_maintainer.pl with the correct command-line options, and follow all the suggestions provided by reddit, Phoronix and 4chan, only to be told that the patch came in during the wrong phase of the moon and they really should have known better.
Quoted 2 lines
Not sure what the real answer is, but something tells me that adding a new domain-specific language to
MAINTAINERSisn't quite it :)
Hmm. How about something such as an initial (friendly) gatekeeper that fronts the submissions and helps steer them in the right direction and in the right format (with follow-up) for those who are unsure?
I'm not sure it'll be possible to achieve at the scale it's needed, but it could be worth a try. Or, just as with some other suggestions, maybe it has already been tried and didn't go anywhere.
-Olof
Quoted 8 lines · Jonathan Corbet
Seriously, this area is a minefield for new developers; it can be discouraging to put together your first patch, carefully follow everything found in SubmittingPatches, CodingStyle, SubmitChecklist, and HOWTO, appease the checkpatch.pl beast, carefully run get_maintainer.pl with the correct command-line options, and follow all the suggestions provided by reddit, Phoronix and 4chan, only to be told that the patch came in during the wrong phase of the moon and they really should have known better.
Here's just an anecdote to support this. There's a highly qualified developer at Sony I was talking to this week, who said that when he sees a bug in the mainline kernel, he usually just ignores it because the hassle-factor of submitting a patch is too high.
-- Tim
Quoted 4 lines · On Thu, 16 Jul 2015 08:52:56 -0700 Tim Bird <[email protected]> wrote:
Quoted 2 lines
Not sure what the real answer is, but something tells me that adding a new domain-specific language to
MAINTAINERSisn't quite it :)Not to rain on my own idea, but I strenuously agree. I think one of the reasons the SubmittingPatches files is not exhaustive is that
Right. Perhaps the solution is to inform maintainers that when they get a patch from a newbie that isn't to their methods, to have them send the author of the patch a nice email that explains to them what they need.
Perhaps we should come up with a boiler plate of what should be written, because not all of the maintainers have a proper tact filter ;-)
Quoted 11 lines
there are too many differences between maintainers for some things, and some things change, even for a single maintainer, given the type of patch and current maintainer circumstances. Adding to
MAINTAINERSdoesn't address this last variability at all.We've been loathe to try to enforce consistency of process for maintainers, thinking it would harm maintainer productivity (and it well might). But it makes automation hard, and you do end up with newbies facing these daunting 110-step processes, which still omit important steps, and might be contradictory for cross-system submissions.
I'm surprised that the Linux kernel, as big as it is, is as uniformed as it is. When you herd a 1000 cats, you can't make them all follow the same path, but you can at least have them all going in the same direction.
-- Steve