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 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 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 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 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 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 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 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
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 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
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 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
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 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 · 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 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 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
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
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 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
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 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
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 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 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 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 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 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 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 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 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 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 98 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
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 2 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.
Sure, if someone is to setup the web form or test mailing list or both, 0day can happily run all supported tests on them, including checkpatch.pl etc. that we normally don't run for the regular git pushes.
Thanks,
Fengguang
Quoted 99 lines · Fengguang Wu
Quoted 98 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
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 7 lines
Quoted 2 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.
Sure, if someone is to setup the web form or test mailing list or both, 0day can happily run all supported tests on them, including checkpatch.pl etc. that we normally don't run for the regular git pushes.
Fengguang,
Do we have sufficient isolation/security in place to test any patch from anyone on a mailing list? I believe someone else raised this concern previously, but it's been a while and I don't remember who it was.
Signature · 2 lines
Darren Hart Intel Open Source Technology Center
Quoted 108 lines · Darren Hart
Quoted 99 lines · Fengguang Wu
Quoted 98 lines · On Thu, Jul 09, 2015 at 01:11:27PM -0700, [email protected] wrote:
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 7 lines
Quoted 2 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.
Sure, if someone is to setup the web form or test mailing list or both, 0day can happily run all supported tests on them, including checkpatch.pl etc. that we normally don't run for the regular git pushes.
Quoted 5 lines
Fengguang,
Do we have sufficient isolation/security in place to test any patch from anyone on a mailing list? I believe someone else raised this concern previously, but it's been a while and I don't remember who it was.
Yes because we test so many git trees, there are isolations since very early time. The kbuild scripts run inside chroot and behind firewall. There is dedicated git mirror server to fetch code from outside which does not actually run the code.
Thanks,
Fengguang
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 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 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 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 · 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 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 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 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 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 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 · 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 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 · 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 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 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 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 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 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 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 · 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 · 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
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 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
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 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 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 · 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 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 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.
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 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 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 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
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 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 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 9 lines · Jiri Kosina
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).
Ah, thanks - I'd not seen that (it's burief in the config file). Not sure I actually find it helpful though since I'm most interested in finding the most recently sent codde, it'd be useful as a sort I could flip at runtime I guess.
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 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 8 lines · On Thu, 16 Jul 2015 16:18:40 +0100 Mark Brown <[email protected]> wrote:
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.
The problem with me is that I'll start a review but wont actually reply. Especially if there's nothing to say about a patch. But if something else comes up, I'll mark where I left off and continue the other work. If I then get another patch series, I do the diff to see if anything changed since I looked over the previous version.
-- Steve
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 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 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 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 1 line · Ralf Baechle
Haven't systems like patchwork mostly obsoleted ping emails?
With patchwork it's only possible to use it if you have a dedicated mailing list for whatever it is you're maintaining which is relatively rare. I'm not really aware of anything else in the same space?
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 6 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?
Except that not all maintainers use patchwork.
Guenter
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 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
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 39 lines · Olof Johansson
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 :)
Quoted 8 lines
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.
That only works is a newbie only submits patches into a single subsystem. Anyone (including 'oldtimers') submitting a patch into different subsystems will still hit the minefield, or would have to utilize the gatekeeper again.
Overall, I don't think this would scale if the gatekeeper is a human. Besides, that gatekeeper would have to be a genius to remember the different per-subsystem submit procedures.
Guenter
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 09:09:35 -0700 Tim Bird <[email protected]> wrote:
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.
Ouch! But that's still no excuse to ignore it. There should be no hassle factor in reporting a bug. Sending a patch along with it is a plus. It at least demonstrates what is wrong. Now it may be a different matter if you want your patch to make it into the kernel.
I've sent hundreds of patches to different subsystem maintainers (and even Linus), where the patch was mostly used to show where the bug was, and my version of the fix, but the final fix was authored by someone else with just a Reported-by contributed to me. I'm fine with that, but others may not be.
I heard that IBM once had a method where if you submitted a change, and that change made it into kernel, even if the final change was not authored by you, you still got credit for it. That's a fabulous way of looking at contributions and giving credit to your employees.
-- Steve
Quoted 19 lines · Steven Rostedt
Quoted 4 lines · On Thu, 16 Jul 2015 09:09:35 -0700 Tim Bird <[email protected]> wrote:
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.
Ouch! But that's still no excuse to ignore it. There should be no hassle factor in reporting a bug. Sending a patch along with it is a plus. It at least demonstrates what is wrong. Now it may be a different matter if you want your patch to make it into the kernel.
I've sent hundreds of patches to different subsystem maintainers (and even Linus), where the patch was mostly used to show where the bug was, and my version of the fix, but the final fix was authored by someone else with just a Reported-by contributed to me. I'm fine with that, but others may not be.
Quoted 4 lines
I heard that IBM once had a method where if you submitted a change, and that change made it into kernel, even if the final change was not authored by you, you still got credit for it. That's a fabulous way of looking at contributions and giving credit to your employees.
That's really good feedback. I've often assumed that if you saw something that needed fixing, you had a responsibility to properly format a patch so as not to burden the maintainer. I've labeled my own "best-effort, but-probably-not-mainlinable" patches as [RFC PATCH..]. Would it be worth having a convention for that sort of thing?
In other contexts, there have been suggestions that even known-to-be-unnacceptable patches be submitted to lkml, just so there's a public record of some driver, feature extension or workaround, that people can evaluate or fix up later. What do people think of this (if they were marked as such)?
-- Tim
Quoted 5 lines · On Thu, 16 Jul 2015 09:24:56 -0700 Tim Bird <[email protected]> wrote:
That's really good feedback. I've often assumed that if you saw something that needed fixing, you had a responsibility to properly format a patch so as not to burden the maintainer. I've labeled my own "best-effort, but-probably-not-mainlinable" patches as [RFC PATCH..]. Would it be worth having a convention for that sort of thing?
At a minimum, the patch should not be html, an attachment, nor have broken whitespace where the patch doesn't apply. But other than that, just report the bug and say "this fixes it for me". And if it is a real bug, the maintainer should take it.
Now, some maintainers will want to let the author have credit for the patch, and may ask the author to format it differently such that they can submit the patch with the original author as credited. I'll do that as not to make the fix just with my name on it. So, if you really just want the fix upstream, and don't want to bother with the hassle and get the author credit for the change, simply state that. Something like:
---
Note, this patch fixes the bug for me. If there's a better solution, or it needs tweaking feel free to make the change. I don't need to be author of the patch, a Reported-by is fine with me.
The '---' is to have that not be part of the change log in case they do take the patch as is.
If it's not much tweaking, I'll take the patch, make the modifications I want, and just add a comment to the change log about my updates, leaving the original author as the author of the patch.
-- Steve
Quoted 27 lines · On Thu, 16 Jul 2015 12:52:16 -0400 Steven Rostedt <[email protected]> wrote:
Quoted 5 lines · On Thu, 16 Jul 2015 09:24:56 -0700 Tim Bird <[email protected]> wrote:
That's really good feedback. I've often assumed that if you saw something that needed fixing, you had a responsibility to properly format a patch so as not to burden the maintainer. I've labeled my own "best-effort, but-probably-not-mainlinable" patches as [RFC PATCH..]. Would it be worth having a convention for that sort of thing?
At a minimum, the patch should not be html, an attachment, nor have broken whitespace where the patch doesn't apply. But other than that, just report the bug and say "this fixes it for me". And if it is a real bug, the maintainer should take it.
Now, some maintainers will want to let the author have credit for the patch, and may ask the author to format it differently such that they can submit the patch with the original author as credited. I'll do that as not to make the fix just with my name on it. So, if you really just want the fix upstream, and don't want to bother with the hassle and get the author credit for the change, simply state that. Something like:
---
Note, this patch fixes the bug for me. If there's a better solution, or it needs tweaking feel free to make the change. I don't need to be author of the patch, a Reported-by is fine with me.
Quoted 7 lines
The '---' is to have that not be part of the change log in case they do take the patch as is.
If it's not much tweaking, I'll take the patch, make the modifications I want, and just add a comment to the change log about my updates, leaving the original author as the author of the patch.
Yes. Absolutely. A patch is a gift - some unwrapping may be required.
We talk a lot about creating tooling to help newbies submit perfect patches. Maybe we need to spend more time creating tooling to help old timers accept imperfect patches.
How hard would it be to get "patch" or "git apply" to apply white-space-damaged patches? Wiggle does a good job of a certain class. I came this --><--- close to getting wiggle to strip trailing '\r', but I never received that third patch to push me over the edge.
How hard would it be to create a pre-commit hook that strips trailing spaces, NormalizesCamelCase, and imposes Reverse Christmas Notation (or whatever it is). It could even add "FOO:" to the start of the patch summary for any patch which modifies the "FOO" subsystem.
How hard would it be to have an SMTP server on submit.kernel.org which only accepts properly formatted patches addressed to "[email protected]", performs basic compile tests, runs get_maintainer and sends it off to the appropriate places. Then Eager Developer could just "./scripts/config-email", answer two questions, and "git submit" (or whatever) would submit their pride and joy to the correct place. ./scripts/config-email would probably install the pre-commit hooks so that bad white space would never even get to git.
NeilBrown
Quoted 3 lines · On Sat, 18 Jul 2015 11:42:28 +1000 NeilBrown <[email protected]> wrote:
We talk a lot about creating tooling to help newbies submit perfect patches. Maybe we need to spend more time creating tooling to help old timers accept imperfect patches.
+1
-- Steve
Quoted 4 lines · Steven Rostedt
On Thu, 16 Jul 2015 09:24:56 -0700
Tim Bird <[email protected]> wrote:
Quoted 8 lines
Quoted 5 lines
That's really good feedback. I've often assumed that if you saw something that needed fixing, you had a responsibility to properly format a patch so as not to burden the maintainer. I've labeled my own "best-effort, but-probably-not-mainlinable" patches as [RFC PATCH..]. Would it be worth having a convention for that sort of thing?
At a minimum, the patch should not be html, an attachment, nor have broken whitespace where the patch doesn't apply. But other than that,
Le me just react on the "no attachment" statement:
As a maintainer, I accept patches as attachments, rework them and properly submit them.
For a newcomer, it's sometimes very difficult to find a way to send patches with git or using a "patch/plain-text-friendly" SMTP server.
This mostly apply for company employees and breaking this barrier could allow us to have more "gifts" in Neil Brown words.
When I recall how difficult it can be to gain a properly configured SMTP server for my Mainline activities in a former company, I completely measure the barrier for contribution it can be.
Quoted 2 lines
just report the bug and say "this fixes it for me". And if it is a real bug, the maintainer should take it.
[..]
Signature · 1 line
Nicolas Ferre
Quoted 14 lines · Nicolas Ferre
Quoted 4 lines · Steven Rostedt
On Thu, 16 Jul 2015 09:24:56 -0700
Tim Bird <[email protected]> wrote:Quoted 8 lines
Quoted 5 lines
That's really good feedback. I've often assumed that if you saw something that needed fixing, you had a responsibility to properly format a patch so as not to burden the maintainer. I've labeled my own "best-effort, but-probably-not-mainlinable" patches as [RFC PATCH..]. Would it be worth having a convention for that sort of thing?
At a minimum, the patch should not be html, an attachment, nor have broken whitespace where the patch doesn't apply. But other than that,
Quoted 6 lines
Le me just react on the "no attachment" statement:
As a maintainer, I accept patches as attachments, rework them and properly submit them.
For a newcomer, it's sometimes very difficult to find a way to send patches with git or using a "patch/plain-text-friendly" SMTP server.
Just a me-too on this. Sometime attachments are the only way to get undamaged patches through an exchange server which a lot of companies who submit drivers force their employees to use. Accepting them isn't a
hardship: git-am actually processes attachments perfectly well.
Also git am --whitespace=fix manages to correct most broken whitespace issues. I usually remember to add it, but perhaps it should be the default?
We've just had long discussions about using tools to help newcomers, let's actually not cause problems over things our tools already cope with.
James
Quoted 12 lines
This mostly apply for company employees and breaking this barrier could allow us to have more "gifts" in Neil Brown words.
When I recall how difficult it can be to gain a properly configured SMTP server for my Mainline activities in a former company, I completely measure the barrier for contribution it can be.
Quoted 2 lines
just report the bug and say "this fixes it for me". And if it is a real bug, the maintainer should take it.
[..]
Quoted 25 lines · James Bottomley
Quoted 12 lines · Nicolas Ferre
Quoted 10 lines · Steven Rostedt
Quoted 5 lines · On Thu, 16 Jul 2015 09:24:56 -0700 Tim Bird <[email protected]> wrote:
That's really good feedback. I've often assumed that if you saw something that needed fixing, you had a responsibility to properly format a patch so as not to burden the maintainer. I've labeled my own "best-effort, but-probably-not-mainlinable" patches as [RFC PATCH..]. Would it be worth having a convention for that sort of thing?
At a minimum, the patch should not be html, an attachment, nor have broken whitespace where the patch doesn't apply. But other than that,
Quoted 6 lines
Le me just react on the "no attachment" statement:
As a maintainer, I accept patches as attachments, rework them and properly submit them.
For a newcomer, it's sometimes very difficult to find a way to send patches with git or using a "patch/plain-text-friendly" SMTP server.Just a me-too on this. Sometime attachments are the only way to get undamaged patches through an exchange server which a lot of companies who submit drivers force their employees to use. Accepting them isn't a
hardship: git-am actually processes attachments perfectly well.
Quoted 7 lines
Also git am --whitespace=fix manages to correct most broken whitespace issues. I usually remember to add it, but perhaps it should be the default?
We've just had long discussions about using tools to help newcomers, let's actually not cause problems over things our tools already cope with.
Applying attached patches is one thing. Adding inline review comments is something different.
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 31 lines · Geert Uytterhoeven
Quoted 29 lines · James Bottomley
Quoted 12 lines · Nicolas Ferre
Quoted 10 lines · Steven Rostedt
Quoted 5 lines · On Thu, 16 Jul 2015 09:24:56 -0700 Tim Bird <[email protected]> wrote:
That's really good feedback. I've often assumed that if you saw something that needed fixing, you had a responsibility to properly format a patch so as not to burden the maintainer. I've labeled my own "best-effort, but-probably-not-mainlinable" patches as [RFC PATCH..]. Would it be worth having a convention for that sort of thing?
At a minimum, the patch should not be html, an attachment, nor have broken whitespace where the patch doesn't apply. But other than that,
Quoted 6 lines
Le me just react on the "no attachment" statement:
As a maintainer, I accept patches as attachments, rework them and properly submit them.
For a newcomer, it's sometimes very difficult to find a way to send patches with git or using a "patch/plain-text-friendly" SMTP server.Just a me-too on this. Sometime attachments are the only way to get undamaged patches through an exchange server which a lot of companies who submit drivers force their employees to use. Accepting them isn't a
hardship: git-am actually processes attachments perfectly well.Also git am --whitespace=fix manages to correct most broken whitespace issues. I usually remember to add it, but perhaps it should be the default?
Quoted 6 lines
Quoted 3 lines
We've just had long discussions about using tools to help newcomers, let's actually not cause problems over things our tools already cope with.
Applying attached patches is one thing. Adding inline review comments is something different.
Every mail tool I know can quote from attachments. One of the side benefits is that reply-all doesn't, so you actually have to quote the section you're commenting on instead of, say, doing reply-all to a 1,000 line patch with a single comment on line 745, which is a real pain for a maintainer ...
James
Quoted 6 lines · James Bottomley
Quoted 4 lines · Geert Uytterhoeven
Quoted 2 lines · James Bottomley
Quoted 1 line · Nicolas Ferre
Le me just react on the "no attachment" statement:
Quoted 7 lines
Quoted 1 line
Adding inline review comments is something different.
Every mail tool I know can quote from attachments. One of the side benefits is that reply-all doesn't, so you actually have to quote the section you're commenting on instead of, say, doing reply-all to a 1,000 line patch with a single comment on line 745, which is a real pain for a maintainer ...
So I have to manually _add_ all sections I want to comment on (and add "> " markers), instead of _deleting_ all sections I don't want to comment on?
Looks suitable for patches which require a single comment only... (Which is usually not the case for patches sent as attachments ;-)
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 16 lines · On Sat, 1 Aug 2015 20:42:29 +0200 Geert Uytterhoeven <[email protected]>…
Quoted 6 lines · James Bottomley
Quoted 4 lines · Geert Uytterhoeven
Quoted 2 lines · James Bottomley
Quoted 1 line · Nicolas Ferre
Le me just react on the "no attachment" statement:
Quoted 7 lines
Quoted 1 line
Adding inline review comments is something different.
Every mail tool I know can quote from attachments. One of the side benefits is that reply-all doesn't, so you actually have to quote the section you're commenting on instead of, say, doing reply-all to a 1,000 line patch with a single comment on line 745, which is a real pain for a maintainer ...
Quoted 6 lines
So I have to manually _add_ all sections I want to comment on (and add "> " markers), instead of _deleting_ all sections I don't want to comment on?
Looks suitable for patches which require a single comment only... (Which is usually not the case for patches sent as attachments ;-)
Claws-mail doesn't make it easy to reply to attachments - you have to use the clumsy "copy/paste/add '>'" that you describe. However asserting that other people should follow a particular work flow because my tools aren't very good does not sound like a convincing argument to me.
If my tools don't work with a workflow that is prima-facie reasonable, then it is my tools that are at fault and I should fix them, not ask someone else to change their workflow.
NeilBrown
Quoted 7 lines · NeilBrown
Claws-mail doesn't make it easy to reply to attachments - you have to use the clumsy "copy/paste/add '>'" that you describe. However asserting that other people should follow a particular work flow because my tools aren't very good does not sound like a convincing argument to me. If my tools don't work with a workflow that is prima-facie reasonable, then it is my tools that are at fault and I should fix them, not ask someone else to change their workflow.
Just in case anyone is collecting data-points from this discussion, pine doesn't make it really easy to include attachment text in-line in reply either.
Signature · 2 lines
Jiri Kosina SUSE Labs
Quoted 10 lines · Jiri Kosina
Quoted 7 lines · NeilBrown
Claws-mail doesn't make it easy to reply to attachments - you have to use the clumsy "copy/paste/add '>'" that you describe. However asserting that other people should follow a particular work flow because my tools aren't very good does not sound like a convincing argument to me. If my tools don't work with a workflow that is prima-facie reasonable, then it is my tools that are at fault and I should fix them, not ask someone else to change their workflow.
Quoted 3 lines
Just in case anyone is collecting data-points from this discussion, pine doesn't make it really easy to include attachment text in-line in reply either.
mutt is a bit fun here - it only works if the attachment has a text MIME type which a lot of the systems that force people to attach patches seem to struggle with.
Quoted 11 lines · Mark Brown
Quoted 9 lines · Jiri Kosina
Quoted 7 lines · NeilBrown
Claws-mail doesn't make it easy to reply to attachments - you have to use the clumsy "copy/paste/add '>'" that you describe. However asserting that other people should follow a particular work flow because my tools aren't very good does not sound like a convincing argument to me. If my tools don't work with a workflow that is prima-facie reasonable, then it is my tools that are at fault and I should fix them, not ask someone else to change their workflow.
Quoted 7 lines
Quoted 3 lines
Just in case anyone is collecting data-points from this discussion, pine doesn't make it really easy to include attachment text in-line in reply either.
mutt is a bit fun here - it only works if the attachment has a text MIME type which a lot of the systems that force people to attach patches seem to struggle with.
You mean the windows habit of attaching them as octet-stream types? I set my binary handler to be emacs (you could make it your editor of choice) so I can pop it up on the attachment and cut and paste quote from the editor. I have to report that this does have some unwanted sid effects in mozilla: some pdf attachments come as octet-stream as well and the binary handler overrides the file type handler ...
James
Quoted 7 lines · James Bottomley
Quoted 3 lines · Mark Brown
mutt is a bit fun here - it only works if the attachment has a text MIME type which a lot of the systems that force people to attach patches seem to struggle with.
You mean the windows habit of attaching them as octet-stream types? I
Something, I guess it's people on Windows systems but I've never really investigated.
Quoted 5 lines
set my binary handler to be emacs (you could make it your editor of choice) so I can pop it up on the attachment and cut and paste quote from the editor. I have to report that this does have some unwanted sid effects in mozilla: some pdf attachments come as octet-stream as well and the binary handler overrides the file type handler ...
That actually isn't needed with mutt - it will *display* binary attachements it doesn't otherwise understand as text as a last resort which does the right thing here. What breaks is that if you reply to a mail with text attacments it'll quote them into the reply but for obvious reasons it doesn't do that for binary attachments.
Quoted 2 lines · On Sun, 2 Aug 2015 08:16:00 +1000 NeilBrown <[email protected]> wrote:
Claws-mail doesn't make it easy to reply to attachments - you have to use the clumsy "copy/paste/add '>'" that you describe.
Two useful claws tricks:
1) "display as text" makes grabbing stuff out of attachments easy
2) "Edit->Special Paste->As quotation" handles much of the rest.
With those, dealing with patches in attachments is fairly painless.
jon
Quoted 8 lines · On Sun, 2 Aug 2015 14:12:03 +0200 Jonathan Corbet <[email protected]> wrote:
Quoted 2 lines · On Sun, 2 Aug 2015 08:16:00 +1000 NeilBrown <[email protected]> wrote:
Claws-mail doesn't make it easy to reply to attachments - you have to use the clumsy "copy/paste/add '>'" that you describe.
Two useful claws tricks:
Quoted 7 lines
1) "display as text" makes grabbing stuff out of attachments easy
2) "
Edit->SpecialPaste->Asquotation" handles much of the rest.With those, dealing with patches in attachments is fairly painless.
jon
Thanks...
So, better add another line to that summary:
Quoted 1 line
If my tools don't work with a workflow that is prima-facie reasonable,
or if I don't know how to use them properly,
Quoted 2 lines
then it is *ME OR* my tools that are at fault and I should fix them, not ask someone else to change their workflow.
NeilBrown
Quoted 4 lines · Steven Rostedt
I heard that IBM once had a method where if you submitted a change, and that change made it into kernel, even if the final change was not authored by you, you still got credit for it. That's a fabulous way of looking at contributions and giving credit to your employees.
You also got a big stuffed penguin for your first kernel patch being accepted, which turned out to be a good motivator for people when half of the cubes on the floor had the penguin but you didn't.
I like the idea of sending out something for a kernel patch, I'll see if the LF could sponsor something like that...
greg k-h
Am Donnerstag, 16. Juli 2015, 18:28:47 schrieb Greg KH:
Quoted 6 lines · Steven Rostedt
Quoted 4 lines
I heard that IBM once had a method where if you submitted a change, and that change made it into kernel, even if the final change was not authored by you, you still got credit for it. That's a fabulous way of looking at contributions and giving credit to your employees.
Quoted 6 lines
You also got a big stuffed penguin for your first kernel patch being accepted, which turned out to be a good motivator for people when half of the cubes on the floor had the penguin but you didn't.
I like the idea of sending out something for a kernel patch, I'll see if the LF could sponsor something like that...
Nice idea :)
Peter
Quoted 6 lines · Greg KH
Quoted 4 lines · Steven Rostedt
I heard that IBM once had a method where if you submitted a change, and that change made it into kernel, even if the final change was not authored by you, you still got credit for it. That's a fabulous way of looking at contributions and giving credit to your employees.
Quoted 6 lines
You also got a big stuffed penguin for your first kernel patch being accepted, which turned out to be a good motivator for people when half of the cubes on the floor had the penguin but you didn't.
I like the idea of sending out something for a kernel patch, I'll see if the LF could sponsor something like that...
Being named in the in the "Kernel development" section of lwn.net is generally a valuable and nice reward.
Bye,
Signature · 1 line
Nicolas Ferre
Quoted 10 lines · Steven Rostedt
Quoted 4 lines · On Thu, 16 Jul 2015 09:09:35 -0700 Tim Bird <[email protected]> wrote:
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.
Ouch! But that's still no excuse to ignore it. There should be no hassle factor in reporting a bug.
Agreed that there is no excuse to ignore it but the hassle factor of reporting is not just the only issue. I find it difficult to just file a bug unless the issue is extremely difficult or I'm completely swamped with other work. I like to think that I generally know what I'm doing and that bug reports should be accompanied with some sort of patch in the common case just out of pride. Other experienced people might be the same but realistically we can't do anything about that because it's about feelings.
The hassle factor of sending patches to unfamiliar maintainers is real though. If I'm privately helping someone post a patch I will try and give them additional information on the maintainer they are dealing with and what snags are specific to that person. Obviously it is not information that is documented anywhere. This hazard is fine if you have someone on hand with that information but I imagine it's rougher if you're on your own.
It's possible that the only tangiable way to address this is if maintainers, where possible, do the basic fixups of a patch *for new people* and explain what they changed and why. Let that person know that in the future they should do the same steps themselves. This is a additional work unfortunately but with luck it would only have to be done one or twice per new person. If it persists then bounce it back saying "ah, this is the same snags as before, you should know how to fix them now". Basic fixups for new peoples patches is something that could potentially be delegated if a maintainer found a few volunteers.
Andrew has a good system for dealing with this class of fixup which works for his workflow. If there are minor fixes then he'll apply "-fix" patches on top and collapse them together before the final merge with Linus. The commit message will have a short note on why the fix was necessary which is enough to know to avoid it in the future. You get an email with the -fix patch is applied and you know you have screwed up when he gets to the -fix-fix-fix-fix patch. The problem gets addressed, the patch gets picked up and the patch submitter learns to avoid that problem in the future. This workflow does not work well with git without rebasing but it is effective.
Quoted 10 lines
<SNIP>
Sending a patch along with it is a
plus. It at least demonstrates what is wrong. Now it may be a different matter if you want your patch to make it into the kernel. I've sent hundreds of patches to different subsystem maintainers (and even Linus), where the patch was mostly used to show where the bug was, and my version of the fix, but the final fix was authored by someone else with just a Reported-by contributed to me. I'm fine with that, but others may not be.
I like using this option on occasion, I think there are a number of people do.
Quoted 5 lines
I heard that IBM once had a method where if you submitted a change, and that change made it into kernel, even if the final change was not authored by you, you still got credit for it. That's a fabulous way of looking at contributions and giving credit to your employees.
That one varied a little and applies to an extent to my current company. A developer assigned a particular task was responsible for getting the job done. If that was with their patch, something functionally equivalent or with someone elses work did not matter. For example, someone else might be fine with the idea, think it's important but hate the method and do it themselves. Your immediate boss might distinguish between whether it was your patch or not but beyond that credit was for getting the job done. That company attitude is not something the community can do much about though unless corporate attitude is being discussed at a high level.
Signature · 2 lines
Mel Gorman SUSE Labs
Quoted 8 lines · On Fri, 17 Jul 2015 11:16:29 +0100 Mel Gorman <[email protected]> wrote:
Agreed that there is no excuse to ignore it but the hassle factor of reporting is not just the only issue. I find it difficult to just file a bug unless the issue is extremely difficult or I'm completely swamped with other work. I like to think that I generally know what I'm doing and that bug reports should be accompanied with some sort of patch in the common case just out of pride. Other experienced people might be the same but realistically we can't do anything about that because it's about feelings.
Quoted 6 lines
The hassle factor of sending patches to unfamiliar maintainers is real though. If I'm privately helping someone post a patch I will try and give them additional information on the maintainer they are dealing with and what snags are specific to that person. Obviously it is not information that is documented anywhere. This hazard is fine if you have someone on hand with that information but I imagine it's rougher if you're on your own.
But as I said below, it's only a hassle if you want your patch applied. It isn't a hassle if you just simply report the bug and say "btw, this patch fixes the issue, use it or make your own, but please fix the bug".
-- 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.
If I play Devil's advocate to the existing Devil's advocate, does that make me one of the good guys ...?
Before we all beat ourselves up for being a complete cesspool of process and timing obsessed freaks, perhaps people would like to reflect on this:
http://www.alexconrad.org/2014/04/the-painful-process-of-submitting-your.html
Sometimes adding layers of carefully documented process and automated abstractions actually ends up giving you precisely what you were trying to avoid.
Seriously, what is the actual problem? Who bites the heads off newbies for sport? I ask because the first patch submission is usually treated with helpfulness and tolerance, at least where I've been on the cc list. The wrong phase of the merge cycle can be a bugger, particularly when most people's attention is elsewhere, but it's not like it's a huge deterrent. We all have developers who'd rather spit rats than submit a patch to $opensourceprojecttheyfoundabugin but then, it's sometimes because the reply might contradict their own mythology (or question their reputation). Before we embark on a huge does of hair shirt and a lavish process dump, what is the problem we're trying to solve?
James
Quoted 10 lines · On Thu, 16 Jul 2015 19:24:35 +0300 James Bottomley…
Seriously, what is the actual problem? Who bites the heads off newbies for sport? I ask because the first patch submission is usually treated with helpfulness and tolerance, at least where I've been on the cc list. The wrong phase of the merge cycle can be a bugger, particularly when most people's attention is elsewhere, but it's not like it's a huge deterrent. We all have developers who'd rather spit rats than submit a patch to $opensourceprojecttheyfoundabugin but then, it's sometimes because the reply might contradict their own mythology (or question their reputation). Before we embark on a huge does of hair shirt and a lavish process dump, what is the problem we're trying to solve?
Our reputation. No seriously, the issue isn't really with what we do today, it's more about what we did yesterday. LKML use to be extremely cruel. It can still be with a few maintainers, but they are now the exception and not the norm.
It's also headlines with Linus swearing and calling people names. Although, those too are few and far between, and Linus only does that to people he knows. I haven't seen him do that with anyone that is new to the list.
As I stated in other emails, we really don't need to change. We just need to be conscious about what we say to patch submitters, and perhaps all we need is reminders to be "nice".
I have no idea how to fix the "reputation" issue, and those that I have met that state "I'll never participate in Linux development again!", when asked, it has to do with something they encountered 10 years ago. All I have to say to them is, "come back, things have changed".
-- Steve
Quoted 10 lines · James Bottomley
Seriously, what is the actual problem? Who bites the heads off newbies for sport? I ask because the first patch submission is usually treated with helpfulness and tolerance, at least where I've been on the cc list. The wrong phase of the merge cycle can be a bugger, particularly when most people's attention is elsewhere, but it's not like it's a huge deterrent. We all have developers who'd rather spit rats than submit a patch to $opensourceprojecttheyfoundabugin but then, it's sometimes because the reply might contradict their own mythology (or question their reputation). Before we embark on a huge does of hair shirt and a lavish process dump, what is the problem we're trying to solve?
I think a lot of it is about perception - the whole "Linus will scream at you for minor issues" meme is pretty strong out there and shapes perceptions regardless of how true it is. That said I do think there's a couple of things that are real.
The response time issues being discussed elsewhere in the thread are real I think - they are the biggest problem I see when I'm helping people with patch submissions. People get very discouraged when they send something off and either get no response at all or find it takes a while, they have difficulty in figuring out how to get people to pay attention. This is unfortunately quite common. It's a really difficult problem to solve with our workflows, at some point submitters have sent a mail to the right people in close enough to the right format so the maintainers *should* look at it but still the submitters don't hear anything back and next steps aren't terribly clear.
I know there's also some stuff that's down to brief replies rather than active hostility - I'm definitely part of the problem here, I need to write a bunch of longer form replies and get a workflow for pasting them into email (actually I think I've got that bit) sorted out. Type the same reply a lot and it's easy to optimise it down to brevity.
Quoted 3 lines · On Thu, 16 Jul 2015 19:24:35 +0300 James Bottomley…
Seriously, what is the actual problem? Who bites the heads off newbies for sport? I ask because the first patch submission is usually treated with helpfulness and tolerance, at least where I've been on the cc list.
So, obviously, I was going for dramatic effect in my other posting. "Biting the heads off newbies" doesn't ordinarily happen. I think the whole Nick episode has shown how tolerant we can be, actually. The point I was trying to make is that there isn't one way to submit a patch to the kernel, there's a hundred ways to submit to various subsystems.
Over on linux-kernel, I just saw a newish developer being politely told that a patch was unacceptable because the local variable declarations were not in reverse-Christmas-tree order. That's not in CodingStyle, and it's certainly not a universal rule in the kernel; it's just one of those things you have to know if you wander into certain scary neighborhoods.
I don't know if there's anything to be done about it, but I do think that this thicket of weird local rules is intimidating to new developers, even if missteps are dealt with politely.
jon
Quoted 13 lines · Jonathan Corbet
Quoted 3 lines · On Thu, 16 Jul 2015 19:24:35 +0300 James Bottomley…
Seriously, what is the actual problem? Who bites the heads off newbies for sport? I ask because the first patch submission is usually treated with helpfulness and tolerance, at least where I've been on the cc list.
So, obviously, I was going for dramatic effect in my other posting. "Biting the heads off newbies" doesn't ordinarily happen. I think the whole Nick episode has shown how tolerant we can be, actually. The point I was trying to make is that there isn't one way to submit a patch to the kernel, there's a hundred ways to submit to various subsystems.
Quoted 5 lines
Over on linux-kernel, I just saw a newish developer being politely told that a patch was unacceptable because the local variable declarations were not in reverse-Christmas-tree order. That's not in CodingStyle, and it's certainly not a universal rule in the kernel; it's just one of those things you have to know if you wander into certain scary neighborhoods.
That's the kind of thing that ought to be raised, politely, in response to such a mail, pointing out that the kernel's coding style should be universal to avoid making people deal with maintainer-specific idiosyncrasies. A few reminders of that from other kernel maintainers couldn't hurt.
Such additional requirements don't seem onerous to the maintainer making them, but add them up across all maintainers and you have a horrendous mess.
- Josh Triplett
Quoted 5 lines · On Fri, 17 Jul 2015 09:59:26 -0700 Josh Triplett <[email protected]> wrote:
That's the kind of thing that ought to be raised, politely, in response to such a mail, pointing out that the kernel's coding style should be universal to avoid making people deal with maintainer-specific idiosyncrasies. A few reminders of that from other kernel maintainers couldn't hurt.
Well, sometimes its maintainers that are telling other maintainers what to do. It's not just newbies that get this treatment.
Quoted 5 lines
Such additional requirements don't seem onerous to the maintainer making them, but add them up across all maintainers and you have a horrendous mess.
Perhaps if someone is sending you a one time patch, and you have your own idiosyncrasy outside of CodingStyle, then it should be the maintainer that makes the clean up. If someone starts sending you patch series and may become a new player in your subsystem, then you can have them start submitting such stylized formatting. But those types of comments really shouldn't be made to the fly by patcher.
-- Steve
Quoted 20 lines · Steven Rostedt
Quoted 5 lines · On Fri, 17 Jul 2015 09:59:26 -0700 Josh Triplett <[email protected]> wrote:
That's the kind of thing that ought to be raised, politely, in response to such a mail, pointing out that the kernel's coding style should be universal to avoid making people deal with maintainer-specific idiosyncrasies. A few reminders of that from other kernel maintainers couldn't hurt.
Well, sometimes its maintainers that are telling other maintainers what to do. It's not just newbies that get this treatment.
Quoted 5 lines
Such additional requirements don't seem onerous to the maintainer making them, but add them up across all maintainers and you have a horrendous mess.
Quoted 6 lines
Perhaps if someone is sending you a one time patch, and you have your own idiosyncrasy outside of CodingStyle, then it should be the maintainer that makes the clean up. If someone starts sending you patch series and may become a new player in your subsystem, then you can have them start submitting such stylized formatting. But those types of comments really shouldn't be made to the fly by patcher.
Alternatively, if you have idiosyncrasies outside of CodingStyle (or SubmittingPatches) that are useful, you could propose them for inclusion in the kernel-wide style. And if they're not useful enough to go there, perhaps they shouldn't be enforced *anywhere*.
I'm not talking about things like how functions should be used in various subsystems (e.g. "the function assigned to this ops field must satisfy these invariants"); I'm talking about things like "in *this* subsystem, your variable declarations should be sorted in descending order of how mellifluous the letters in its name sound when mapped to a two-octave chromatical musical scale and played through a flugelhorn".
- Josh Triplett
Quoted 5 lines · On Fri, 17 Jul 2015 10:11:51 -0600 Jonathan Corbet <[email protected]> wrote:
Over on linux-kernel, I just saw a newish developer being politely told that a patch was unacceptable because the local variable declarations were not in reverse-Christmas-tree order. That's not in CodingStyle, and it's certainly not a universal rule in the kernel; it's just one of those things you have to know if you wander into certain scary neighborhoods.
As I know a few maintainers that like the "reverse-xmas-tree" order, perhaps we could add that to CodingStyle in a section of:
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
Because things like reverse x-mas tree order isn't something people are against doing. But some may not care if you do or don't. So listing all the things that a few maintainers share, may be good.
Of course you hit a brick wall when there's two types of styles that maintainers disagree on.
/*
* What is the question?
* To add a space at the top of a comment?
*/
/* Or not to add a space at the top of a comment?
* That is the question!
*/
But really, when there's small things like indentation that is submitted and I don't like, I don't even bother telling the author, I'll just fix it myself and note in the change log "fixed up whitespace".
-- Steve
Quoted 41 lines · Steven Rostedt
Quoted 1 line · On Fri, 17 Jul 2015 10:11:51 -0600 Jonathan Corbet <[email protected]> wrote:
Over on linux-kernel, I just saw a newish developer being politely
told
Quoted 2 lines
that a patch was unacceptable because the local variable declarations were not in reverse-Christmas-tree order. That's not in CodingStyle,
and
Quoted 1 line
it's certainly not a universal rule in the kernel; it's just one of
those
Quoted 1 line
things you have to know if you wander into certain scary
neighborhoods.
As I know a few maintainers that like the "reverse-xmas-tree" order, perhaps we could add that to CodingStyle in a section of:
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
Because things like reverse x-mas tree order isn't something people are against doing. But some may not care if you do or don't. So listing all the things that a few maintainers share, may be good.
Of course you hit a brick wall when there's two types of styles that maintainers disagree on.
/*
* What is the question?
* To add a space at the top of a comment?
*//* Or not to add a space at the top of a comment?
* That is the question!
*/
Quoted 4 lines
But really, when there's small things like indentation that is submitted and I don't like, I don't even bother telling the author, I'll just fix it myself and note in the change log "fixed up whitespace".
If you do that, and I get 500 coccinelle generated patches for SCSI switching the includes to reverse Christmas tree one file at a time, I'm afraid I'll have to shoot you.
James
Quoted 6 lines
-- Steve
_______________________________________________
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 10 lines · James Bottomley
Quoted 7 lines
But really, when there's small things like indentation that is submitted and I don't like, I don't even bother telling the author, I'll just fix it myself and note in the change log "fixed up whitespace".
If you do that, and I get 500 coccinelle generated patches for SCSI switching the includes to reverse Christmas tree one file at a time, I'm afraid I'll have to shoot you.
I wanted to comment that I tend to do the same, but given your reply I'd rather be silent.
On a side note, sending an e-mail with more than 80 (or maybe 72) columns per line may result in an angry e-mail from some maintainers.
Guenter
Quoted 10 lines · On Fri, 17 Jul 2015 20:43:12 +0300 James Bottomley…
Quoted 5 lines
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
If you do that, and I get 500 coccinelle generated patches for SCSI switching the includes to reverse Christmas tree one file at a time, I'm afraid I'll have to shoot you.
I'll remember to wear my bullet proof vest coming to KS.
Should stress that just some people prefer them. Heck, we can teach checkpatch.pl to look at what file is being modified and see what formats the maintainer of the file wants. :-)
-- Steve
Quoted 13 lines · Steven Rostedt
Quoted 9 lines · On Fri, 17 Jul 2015 20:43:12 +0300 James Bottomley…
Quoted 5 lines
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
Quoted 7 lines
Quoted 1 line
If you do that, and I get 500 coccinelle generated patches for SCSI switching the includes to reverse Christmas tree one file at a time, I'm afraid I'll have to shoot you.
I'll remember to wear my bullet proof vest coming to KS.
Should stress that just some people prefer them. Heck, we can teach checkpatch.pl to look at what file is being modified and see what formats the maintainer of the file wants. :-)
We're way off in the weeds here, and whenever this topic comes up, we end up focusing on the minor annoyances that come from submitting new code. Small variations in coding style, function naming and general methods for working with a maintainer are sure to vary.
Looking at Jon's statistics, we don't have a problem bringing new people into the kernel. What can we do to help the new people be more productive? My own feeling is feedback, testing and documentation are more important than 100% consistency between maintainers.
I love Greg's swag idea, I'm sure
more than one LF member would
be willing to help sponsor
such a thing.
-chris
Quoted 33 lines · On Fri, 17 Jul 2015 15:30:13 -0400 Chris Mason <[email protected]> wrote:
Quoted 13 lines · Steven Rostedt
Quoted 9 lines · On Fri, 17 Jul 2015 20:43:12 +0300 James Bottomley…
Quoted 5 lines
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
Quoted 7 lines
Quoted 1 line
If you do that, and I get 500 coccinelle generated patches for SCSI switching the includes to reverse Christmas tree one file at a time, I'm afraid I'll have to shoot you.
I'll remember to wear my bullet proof vest coming to KS.
Should stress that just some people prefer them. Heck, we can teach checkpatch.pl to look at what file is being modified and see what formats the maintainer of the file wants. :-)
We're way off in the weeds here, and whenever this topic comes up, we end up focusing on the minor annoyances that come from submitting new code. Small variations in coding style, function naming and general methods for working with a maintainer are sure to vary.
Looking at Jon's statistics, we don't have a problem bringing new people into the kernel. What can we do to help the new people be more productive? My own feeling is feedback, testing and documentation are more important than 100% consistency between maintainers.
Quoted 6 lines
I love Greg's swag idea, I'm sure
more than one LF member would
be willing to help sponsor
such a thing.-chris
I wondered
why I felt like
I needed to look for
my lawn mower. Yeah, we are
bike shedding here. We need to figure out how to get people not afraid of submitting their first patch. I agree, that swag idea may be a good one.
-- Steve
Quoted 43 lines · Steven Rostedt
Quoted 33 lines · On Fri, 17 Jul 2015 15:30:13 -0400 Chris Mason <[email protected]> wrote:
Quoted 13 lines · Steven Rostedt
Quoted 9 lines · On Fri, 17 Jul 2015 20:43:12 +0300 James Bottomley…
Quoted 5 lines
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
Quoted 7 lines
Quoted 1 line
If you do that, and I get 500 coccinelle generated patches for SCSI switching the includes to reverse Christmas tree one file at a time, I'm afraid I'll have to shoot you.
I'll remember to wear my bullet proof vest coming to KS.
Should stress that just some people prefer them. Heck, we can teach checkpatch.pl to look at what file is being modified and see what formats the maintainer of the file wants. :-)
We're way off in the weeds here, and whenever this topic comes up, we end up focusing on the minor annoyances that come from submitting new code. Small variations in coding style, function naming and general methods for working with a maintainer are sure to vary.
Looking at Jon's statistics, we don't have a problem bringing new people into the kernel. What can we do to help the new people be more productive? My own feeling is feedback, testing and documentation are more important than 100% consistency between maintainers.
Quoted 6 lines
I love Greg's swag idea, I'm sure
more than one LF member would
be willing to help sponsor
such a thing.-chris
Quoted 8 lines
I wondered
why I felt like
I needed to look for
my lawn mower. Yeah, we are
bike shedding here. We need to figure out how to get people not afraid of submitting their first patch. I agree, that swag idea may be a good one.
The first patch really doesn't seem to be a problem. At least from the stats I've seen so far. How do we get the 10..100th patches, hopefully without 90% of them being whitespace fixes?
We're not going to be able to answer these without actual data. This means surveys and talking with new developers that we really hope to turn into long term members of the community.
-chris
Quoted 8 lines · Chris Mason
The first patch really doesn't seem to be a problem. At least from the stats I've seen so far. How do we get the 10..100th patches, hopefully without 90% of them being whitespace fixes?
We're not going to be able to answer these without actual data. This means surveys and talking with new developers that we really hope to turn into long term members of the community.
I may have a data set that is relevant here.
Last year I surveyed developers, targeting those who
1) had made a change to the kernel that shipped in a commercial product, (defined as "qualified" in the survey analysis)
and
2) did not make contributions to mainline
There were 93 out of 278 "qualified" developers who never submitted a patch. That's about 33% of the developers who responded to the survey. I suspect that the no-submission rate for developers who either did not see the survey or did not respond to it is much, much higher. This survey was focused on developers in the consumer electronics field.
25% of all survey respondents (not just the "qualified" ones) reported they did not know how to contribute a patch.
The survey was not detailed enough to determine what parts of the submission process caused the most reluctance to contribute.
I would guess (not very scientifically) that although we have thousands of developers contributing to mainline, the pool of developers paid by their companies to make products is in the range of 10s of thousands, and our rate of conversion to contributors is under 10%. (I'm not sure if that's good or bad.)
-- Tim
Quoted 28 lines · Tim Bird
Quoted 8 lines · Chris Mason
The first patch really doesn't seem to be a problem. At least from the stats I've seen so far. How do we get the 10..100th patches, hopefully without 90% of them being whitespace fixes?
We're not going to be able to answer these without actual data. This means surveys and talking with new developers that we really hope to turn into long term members of the community.
I may have a data set that is relevant here.
Last year I surveyed developers, targeting those who
1) had made a change to the kernel that shipped in a commercial product, (defined as "qualified" in the survey analysis)
and
2) did not make contributions to mainlineThere were 93 out of 278 "qualified" developers who never submitted a patch. That's about 33% of the developers who responded to the survey. I suspect that the no-submission rate for developers who either did not see the survey or did not respond to it is much, much higher. This survey was focused on developers in the consumer electronics field.
25% of all survey respondents (not just the "qualified" ones) reported they did not know how to contribute a patch.
Quoted 8 lines
The survey was not detailed enough to determine what parts of the submission process caused the most reluctance to contribute.
I would guess (not very scientifically) that although we have thousands of developers contributing to mainline, the pool of developers paid by their companies to make products is in the range of 10s of thousands, and our rate of conversion to contributors is under 10%. (I'm not sure if that's good or bad.)
I love hard data on this topic, and I really like the idea of trying to find the pool of actual kernel developers vs the pool of people visible on the mailing list. 10:1 makes me sad, but I'm not that surprised.
Still, I'll channel Greg for a minute and google "how to send a patch to the linux kernel". I'd definitely believe people don't know how to get their employer to prioritize (allow?) sending the patches in, but I can't stretch to they don't know how to do it at all.
-chris
Quoted 4 lines · Chris Mason
Still, I'll channel Greg for a minute and google "how to send a patch to the linux kernel". I'd definitely believe people don't know how to get their employer to prioritize (allow?) sending the patches in, but I can't stretch to they don't know how to do it at all.
There is the gap before that where they know it's an option for "people like them" at all, especially people who are more used to working on proprietary or vendor systems where you just can't contribute back.
Quoted 10 lines · Steven Rostedt
Quoted 5 lines · On Fri, 17 Jul 2015 10:11:51 -0600 Jonathan Corbet <[email protected]> wrote:
Over on linux-kernel, I just saw a newish developer being politely told that a patch was unacceptable because the local variable declarations were not in reverse-Christmas-tree order. That's not in CodingStyle, and it's certainly not a universal rule in the kernel; it's just one of those things you have to know if you wander into certain scary neighborhoods.
Quoted 7 lines
As I know a few maintainers that like the "reverse-xmas-tree" order, perhaps we could add that to CodingStyle in a section of:
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
A world of *no*. If your style is not universal, and you can't get a general consensus among kernel maintainers that it should be a requirement across the entire kernel, then *no*. We should not have per-subsystem formatting rules.
Quoted 8 lines
/*
* What is the question?
* To add a space at the top of a comment?
*//* Or not to add a space at the top of a comment?
* That is the question!
*/
While I'm not going to advocate that we mass-fix existing code in a subsystem for consistent formatting, this is *exactly* the kind of thing that we do not need any more of; one such idiosyncrasy is one too many.
- Josh Triplett
Quoted 10 lines · On Fri, 17 Jul 2015 12:02:23 -0700 [email protected] wrote:
Quoted 4 lines
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
A world of *no*. If your style is not universal, and you can't get a general consensus among kernel maintainers that it should be a requirement across the entire kernel, then *no*. We should not have per-subsystem formatting rules.
Um, we have it today, and we'll have it tomorrow. Sorry, but the Linux kernel is not run by management. It's a huge community effort with some of the brightest minds in the world working on it. Each subsystem of the kernel is a project in itself. We're lucky we have the consensus that we have.
Quoted 5 lines
Quoted 5 lines
/*
* What is the question?
* To add a space at the top of a comment?
*/
Quoted 7 lines
Quoted 3 lines
/* Or not to add a space at the top of a comment?
* That is the question!
*/While I'm not going to advocate that we mass-fix existing code in a subsystem for consistent formatting, this is *exactly* the kind of thing that we do not need any more of; one such idiosyncrasy is one too many.
Then there's no issue here. Each maintainer is free to tell people to x-mas tree their variables or not. Look, kernel development is complex and if your biggest hangup of getting a patch into the kernel is that the maintainer requires you to modify some whitespace on rearrange your variables, then you probably should get out of kernel development and enter a field of bike shed exterior design.
-- Steve
Quoted 13 lines · Steven Rostedt
Quoted 10 lines · On Fri, 17 Jul 2015 12:02:23 -0700 [email protected] wrote:
Quoted 4 lines
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
A world of *no*. If your style is not universal, and you can't get a general consensus among kernel maintainers that it should be a requirement across the entire kernel, then *no*. We should not have per-subsystem formatting rules.
Quoted 5 lines
Um, we have it today, and we'll have it tomorrow. Sorry, but the Linux kernel is not run by management. It's a huge community effort with some of the brightest minds in the world working on it. Each subsystem of the kernel is a project in itself. We're lucky we have the consensus that we have.
Documenting it is giving up and saying it's OK for this to happen, rather than continuing to address issues as we discover them. At the moment, there's one well-known one (the comment item mentioned below), and it exists mostly as an extension of the standard rule "match the surrounding code rather than rewriting it". That isn't carte blanche for intentionally having a gratuitously different style in different files.
Quoted 9 lines
Quoted 9 lines
Quoted 8 lines
/*
* What is the question?
* To add a space at the top of a comment?
*//* Or not to add a space at the top of a comment?
* That is the question!
*/
Quoted 6 lines
Quoted 3 lines
While I'm not going to advocate that we mass-fix existing code in a subsystem for consistent formatting, this is *exactly* the kind of thing that we do not need any more of; one such idiosyncrasy is one too many.
Then there's no issue here. Each maintainer is free to tell people to x-mas tree their variables or not.
And other maintainers can and should tell them to cut it out. I'm not suggesting this problem should be solved by top-down management, but by community consensus.
Quoted 5 lines
Look, kernel development is complex
and if your biggest hangup of getting a patch into the kernel is that the maintainer requires you to modify some whitespace on rearrange your variables, then you probably should get out of kernel development and enter a field of bike shed exterior design.
If your biggest hangup as a maintainer is that people send you patches that don't have variables sorted in some particular order, perhaps you should get out of kernel development and get into bike shed colorimetry consulting. We have enough problems getting quality patches by the metrics that *actually* correlate to quality. And as others have pointed out in this thread, many people produce patches across numerous subsystems.
- Josh Triplett
Quoted 7 lines · On Fri, 17 Jul 2015 13:24:12 -0700 [email protected] wrote:
If your biggest hangup as a maintainer is that people send you patches that don't have variables sorted in some particular order, perhaps you should get out of kernel development and get into bike shed colorimetry consulting. We have enough problems getting quality patches by the metrics that *actually* correlate to quality. And as others have pointed out in this thread, many people produce patches across numerous subsystems.
I personally don't have any issue with my own idiosyncrasies not being met. They are usually minor, and I'll fix up the patch (and document it in the change log). These minor idiosyncrasies make maintaining code easier. Everyone has a little personal style, and when the code aligns to that style, it is usually easier to review it and understand it.
Anything that helps you to understand the code is a bonus.
I too have sent out patches across numerous subsystems. When a maintainer asks me to modify it a certain way, I just do it.
-- Steve
Quoted 9 lines · Steven Rostedt
Quoted 7 lines · On Fri, 17 Jul 2015 13:24:12 -0700 [email protected] wrote:
If your biggest hangup as a maintainer is that people send you patches that don't have variables sorted in some particular order, perhaps you should get out of kernel development and get into bike shed colorimetry consulting. We have enough problems getting quality patches by the metrics that *actually* correlate to quality. And as others have pointed out in this thread, many people produce patches across numerous subsystems.
Quoted 4 lines
I personally don't have any issue with my own idiosyncrasies not being met. They are usually minor, and I'll fix up the patch (and document it in the change log). These minor idiosyncrasies make maintaining code easier.
That's perfectly reasonable. If you want to take the time making the code in your area conform to additional requirements above and beyond those of the kernel as a whole, go for it. I appreciate that you don't ask others to do it for you.
- Josh Triplett
On Fri, 17 Jul 2015 13:48:56 -0700
[email protected] wrote:
\
Quoted 4 lines
That's perfectly reasonable. If you want to take the time making the code in your area conform to additional requirements above and beyond those of the kernel as a whole, go for it. I appreciate that you don't ask others to do it for you.
I can't say I never do. I just don't do it if it's the only change I'm asking. If there's a logic change or bug I see in my review, I'll add my comments about formatting along with it.
In fact, I went so far once to fix up a patch submitted by someone that didn't come close to following CodingStyle. But I wanted the change. I still gave the guy credit, but that took way too much time than it should of. But that was an exception because the code submitted was really worth while.
-- Steve
On Fri, 17 Jul 2015, Steven Rostedt wrote:
[ ... snip ... ]
Quoted 2 lines
But that was an exception because the code submitted was really worth while
This really made me wonder. Maybe we should really focus on why such ocasions need to be pointed out as exceptions.
Is it that Linux kernel development got hyped so much that everyone wants to have that bullet in his CV, no matter how stupid the submitted patch would be?
If so, what should we do to change it?
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Should we stop publishing all the statistics? I believe there is no question that those are one of the primary drivers of useless submissions. Once maintainers get DoSed by submissions of wrong and/or useless patches that eat non-negligible amount of their time, we're in trouble.
Signature · 2 lines
Jiri Kosina SUSE Labs
Quoted 8 lines · Jiri Kosina
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Should we stop publishing all the statistics? I believe there is no question that those are one of the primary drivers of useless submissions. Once maintainers get DoSed by submissions of wrong and/or useless patches that eat non-negligible amount of their time, we're in trouble.
I don't think it's the statistics that are the primary driver of such contributions. Rather, I would suggest that it's so non-trivially difficult to follow the substantial volume of process needed to get something into the kernel that it's worth doing a trial run with a trivial change before trying to do something of substance.
And fixes for certain classes of compiler or sparse warnings have value themselves.
- Josh Triplett
Quoted 6 lines · On Mon, 20 Jul 2015 00:19:56 +0200 (CEST) Jiri Kosina <[email protected]> wrote:
On Fri, 17 Jul 2015, Steven Rostedt wrote:
[ ... snip ... ]
Quoted 2 lines
But that was an exception because the code submitted was really worth while
Quoted 7 lines
This really made me wonder. Maybe we should really focus on why such ocasions need to be pointed out as exceptions.
Is it that Linux kernel development got hyped so much that everyone wants to have that bullet in his CV, no matter how stupid the submitted patch would be?
Note, it was an exception because I wanted the change. There's changes that add things I see worth while for others, but probably not so much for myself. Those changes I wont be bending over backward for. If someone submits a change that I really want, then I would do a lot to make sure its in.
For an example of a change that I see worth while for others and not for myself is live kernel patching ;-) If those developers want those changes in, they need to follow the process :-)
-- Steve
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
Quoted 5 lines
Should we stop publishing all the statistics? I believe there is no question that those are one of the primary drivers of useless submissions. Once maintainers get DoSed by submissions of wrong and/or useless patches that eat non-negligible amount of their time, we're in trouble.
Quoted 5 lines · Zefan Li
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Quoted 8 lines
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
That's exactly the kind of thing that we *shouldn't* do.
Think about that from the new contributor's perspective. They've made a change to the kernel that has a small but non-zero value. They've just managed to work out how to jump through all the hoops needed to prepare and submit it properly for the kernel, through some combination of reading, lurking, and mentorship. And the first response they see is a maintainer like you saying "please don't send this kind of patch".
Yeah, they probably won't do that again. Congratulations, you defeated the newbie and thwarted their evil maintainer-time-wasting scheme! Hail the conquering hero; insert victory fanfare here. If you and others keep up that vigilance, perhaps one day all maintainers can rest easy, knowing they'll never again have to deal with new contributors.
</sarcasm>
It's perfectly reasonable to tell someone that, since they've gotten the hang of sending kernel patches, they should move on to more substantial changes, and leave simpler fixes to other potential new contributors. But that's different than telling them their patch is unwelcome.
(If someone sends in a patch that's actively wrong, sure, go right ahead and tell them what's wrong with it. But there's a difference between "wrong" and just "not that important".)
- Josh Triplett
Quoted 32 lines · Josh Triplett
Quoted 5 lines · Zefan Li
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Quoted 8 lines
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
That's exactly the kind of thing that we *shouldn't* do.
Think about that from the new contributor's perspective. They've made a change to the kernel that has a small but non-zero value. They've just managed to work out how to jump through all the hoops needed to prepare and submit it properly for the kernel, through some combination of reading, lurking, and mentorship. And the first response they see is a maintainer like you saying "please don't send this kind of patch".
Yeah, they probably won't do that again. Congratulations, you defeated the newbie and thwarted their evil maintainer-time-wasting scheme! Hail the conquering hero; insert victory fanfare here. If you and others keep up that vigilance, perhaps one day all maintainers can rest easy, knowing they'll never again have to deal with new contributors.
</sarcasm>
Quoted 9 lines
It's perfectly reasonable to tell someone that, since they've gotten the hang of sending kernel patches, they should move on to more substantial changes, and leave simpler fixes to other potential new contributors. But that's different than telling them their patch is unwelcome.
(If someone sends in a patch that's actively wrong, sure, go right ahead and tell them what's wrong with it. But there's a difference between "wrong" and just "not that important".)
Absolutely agree.
Guenter
Quoted 32 lines · Josh Triplett
Quoted 5 lines · Zefan Li
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Quoted 8 lines
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
That's exactly the kind of thing that we *shouldn't* do.
Think about that from the new contributor's perspective. They've made a change to the kernel that has a small but non-zero value. They've just managed to work out how to jump through all the hoops needed to prepare and submit it properly for the kernel, through some combination of reading, lurking, and mentorship. And the first response they see is a maintainer like you saying "please don't send this kind of patch".
Yeah, they probably won't do that again. Congratulations, you defeated the newbie and thwarted their evil maintainer-time-wasting scheme! Hail the conquering hero; insert victory fanfare here. If you and others keep up that vigilance, perhaps one day all maintainers can rest easy, knowing they'll never again have to deal with new contributors.
</sarcasm>
Quoted 8 lines
It's perfectly reasonable to tell someone that, since they've gotten the hang of sending kernel patches, they should move on to more substantial changes, and leave simpler fixes to other potential new contributors. But that's different than telling them their patch is unwelcome.
(If someone sends in a patch that's actively wrong, sure, go right ahead and tell them what's wrong with it. But there's a difference between "wrong" and just "not that important".)
I think that's the wrong attitude in so many ways. Good teachers don't accept crap. They throw it back at you with precisely the contempt it deserves and a note as to how it should be improved. Accepting less than the best encourages mediocrity; it's bad for teaching, bad for society and ultimately bad for the individual.
The constructive way to respond is to explain that this patch doesn't add value, so it's not really of the calibre that we're looking for, but then pull out one of the longstanding problems in a related area (or sometimes something you just spotted looking at the code again) and ask if the person would care to have a crack at that.
James
Quoted 38 lines · James Bottomley
Quoted 37 lines · Josh Triplett
Quoted 5 lines · Zefan Li
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Quoted 8 lines
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
That's exactly the kind of thing that we *shouldn't* do.
Think about that from the new contributor's perspective. They've made a change to the kernel that has a small but non-zero value. They've just managed to work out how to jump through all the hoops needed to prepare and submit it properly for the kernel, through some combination of reading, lurking, and mentorship. And the first response they see is a maintainer like you saying "please don't send this kind of patch".
Yeah, they probably won't do that again. Congratulations, you defeated the newbie and thwarted their evil maintainer-time-wasting scheme! Hail the conquering hero; insert victory fanfare here. If you and others keep up that vigilance, perhaps one day all maintainers can rest easy, knowing they'll never again have to deal with new contributors.
</sarcasm>
It's perfectly reasonable to tell someone that, since they've gotten the hang of sending kernel patches, they should move on to more substantial changes, and leave simpler fixes to other potential new contributors. But that's different than telling them their patch is unwelcome.
Quoted 6 lines
Quoted 3 lines
(If someone sends in a patch that's actively wrong, sure, go right ahead and tell them what's wrong with it. But there's a difference between "wrong" and just "not that important".)
I think that's the wrong attitude in so many ways. Good teachers don't accept crap.
We don't seem to be talking about the same kind of patches, then. If someone sends in incorrect patches, by all means reject those patches. But a patch that improves code, even a very minor improvement, should always be welcome.
(This doesn't mean that mechanically fixing compiler warnings, for instance, is always an improvement. For instance, shutting up the compiler rather than actually fixing the warning is not a good idea. But when the patch actually fixes something, even something minor, it's worth accepting.)
- Josh Triplett
Quoted 43 lines · Josh Triplett
Quoted 42 lines · James Bottomley
Quoted 40 lines · Josh Triplett
Quoted 5 lines · Zefan Li
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Quoted 8 lines
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
That's exactly the kind of thing that we *shouldn't* do.
Think about that from the new contributor's perspective. They've made a change to the kernel that has a small but non-zero value. They've just managed to work out how to jump through all the hoops needed to prepare and submit it properly for the kernel, through some combination of reading, lurking, and mentorship. And the first response they see is a maintainer like you saying "please don't send this kind of patch".
Yeah, they probably won't do that again. Congratulations, you defeated the newbie and thwarted their evil maintainer-time-wasting scheme! Hail the conquering hero; insert victory fanfare here. If you and others keep up that vigilance, perhaps one day all maintainers can rest easy, knowing they'll never again have to deal with new contributors.
</sarcasm>
It's perfectly reasonable to tell someone that, since they've gotten the hang of sending kernel patches, they should move on to more substantial changes, and leave simpler fixes to other potential new contributors. But that's different than telling them their patch is unwelcome.
(If someone sends in a patch that's actively wrong, sure, go right ahead and tell them what's wrong with it. But there's a difference between "wrong" and just "not that important".)
Quoted 7 lines
Quoted 2 lines
I think that's the wrong attitude in so many ways. Good teachers don't accept crap.
We don't seem to be talking about the same kind of patches, then. If someone sends in incorrect patches, by all means reject those patches. But a patch that improves code, even a very minor improvement, should always be welcome.
"Improvement" is probably the issue. Improvement to me means
1. Adds a new user visible feature that will have consumers
2. makes a user visible change that adds value (ideally a bug fix, but I think adding extra debug or other interfaces can count here)
3. materially improves the maintainability of the code.
The third one seems to be where there's most disagreement. Usually the guideline I use for this is that for older files is just don't touch. If someone really wants to improve the file then they get to maintain it as well (we've had some success with this) otherwise generally such patches aren't welcome.
Quoted 5 lines
(This doesn't mean that mechanically fixing compiler warnings, for instance, is always an improvement. For instance, shutting up the compiler rather than actually fixing the warning is not a good idea. But when the patch actually fixes something, even something minor, it's worth accepting.)
I don't agree that all improvements, however minor are worthwhile. There's a cost to reviewing and merging ... that should be outweighed by the value of the contribution. The scarcest thing we have is review bandwidth and we shouldn't waste it on minor improvements that are very minor. That said, I also don't direct or control the reviewers and they mostly tend to concentrate on what they consider to be interesting stuff, so I often find that patches like this often languish for lack of review ... that's a good opportunity to point out that a more substantive change would receive more attention.
James
Quoted 6 lines · James Bottomley
I don't agree that all improvements, however minor are worthwhile. There's a cost to reviewing and merging ... that should be outweighed by the value of the contribution. The scarcest thing we have is review bandwidth and we shouldn't waste it on minor improvements that are very minor.
There is also a cost to *change*. How many times have we seen a trivial patch which actually *breaks* something non-trivial?
We're normally quite good at managing change, and not being conservative purely for conservatism's sake.
But trivial patches are actually the most risky in a number of ways. They often come from inexperienced contributors, who might not spot subtle problems introduced by naïve changes. And they are often made without an in-depth knowledge or study of the code. The contributor just spots a pattern (perhaps with checkpatch), and mechanically fixes every instance they see, without stopping to look hard at each instance.
Hell, I did this when fixing up the krealloc() users relatively recently, getting it wrong in one case. And I really *ought* to know better.
Signature · 2 lines
David Woodhouse Open Source Technology Centre [email protected] Intel Corporation
Quoted 60 lines · James Bottomley
Quoted 43 lines · Josh Triplett
Quoted 42 lines · James Bottomley
Quoted 40 lines · Josh Triplett
Quoted 5 lines · Zefan Li
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Quoted 8 lines
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
That's exactly the kind of thing that we *shouldn't* do.
Think about that from the new contributor's perspective. They've made a change to the kernel that has a small but non-zero value. They've just managed to work out how to jump through all the hoops needed to prepare and submit it properly for the kernel, through some combination of reading, lurking, and mentorship. And the first response they see is a maintainer like you saying "please don't send this kind of patch".
Yeah, they probably won't do that again. Congratulations, you defeated the newbie and thwarted their evil maintainer-time-wasting scheme! Hail the conquering hero; insert victory fanfare here. If you and others keep up that vigilance, perhaps one day all maintainers can rest easy, knowing they'll never again have to deal with new contributors.
</sarcasm>
It's perfectly reasonable to tell someone that, since they've gotten the hang of sending kernel patches, they should move on to more substantial changes, and leave simpler fixes to other potential new contributors. But that's different than telling them their patch is unwelcome.
(If someone sends in a patch that's actively wrong, sure, go right ahead and tell them what's wrong with it. But there's a difference between "wrong" and just "not that important".)
Quoted 7 lines
Quoted 2 lines
I think that's the wrong attitude in so many ways. Good teachers don't accept crap.
We don't seem to be talking about the same kind of patches, then. If someone sends in incorrect patches, by all means reject those patches. But a patch that improves code, even a very minor improvement, should always be welcome.
"Improvement" is probably the issue. Improvement to me means
1. Adds a new user visible feature that will have consumers
2. makes a user visible change that adds value (ideally a bug fix, but I think adding extra debug or other interfaces can count here)
3. materially improves the maintainability of the code.
Quoted 5 lines
The third one seems to be where there's most disagreement. Usually the guideline I use for this is that for older files is just don't touch. If someone really wants to improve the file then they get to maintain it as well (we've had some success with this) otherwise generally such patches aren't welcome.
Agreed.
Quoted 9 lines
Quoted 5 lines
(This doesn't mean that mechanically fixing compiler warnings, for instance, is always an improvement. For instance, shutting up the compiler rather than actually fixing the warning is not a good idea. But when the patch actually fixes something, even something minor, it's worth accepting.)
I don't agree that all improvements, however minor are worthwhile. There's a cost to reviewing and merging ... that should be outweighed by the value of the contribution.
Right. Plus a change making an old file generate less checkpatch.pl warnings may actually *not* be an improvement (even if it doesn't break things actively).
There is code in the kernel that was written with a coding style quite different from the one regarded as a "standard" today and there's nothing wrong with that in principle.
Thanks,
Rafael
Quoted 42 lines · On Mon, 20 Jul 2015 08:15:15 +0100 James Bottomley…
Quoted 32 lines · Josh Triplett
Quoted 5 lines · Zefan Li
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Quoted 8 lines
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
That's exactly the kind of thing that we *shouldn't* do.
Think about that from the new contributor's perspective. They've made a change to the kernel that has a small but non-zero value. They've just managed to work out how to jump through all the hoops needed to prepare and submit it properly for the kernel, through some combination of reading, lurking, and mentorship. And the first response they see is a maintainer like you saying "please don't send this kind of patch".
Yeah, they probably won't do that again. Congratulations, you defeated the newbie and thwarted their evil maintainer-time-wasting scheme! Hail the conquering hero; insert victory fanfare here. If you and others keep up that vigilance, perhaps one day all maintainers can rest easy, knowing they'll never again have to deal with new contributors.
</sarcasm>
Quoted 8 lines
It's perfectly reasonable to tell someone that, since they've gotten the hang of sending kernel patches, they should move on to more substantial changes, and leave simpler fixes to other potential new contributors. But that's different than telling them their patch is unwelcome.
(If someone sends in a patch that's actively wrong, sure, go right ahead and tell them what's wrong with it. But there's a difference between "wrong" and just "not that important".)
Quoted 5 lines
I think that's the wrong attitude in so many ways. Good teachers don't accept crap. They throw it back at you with precisely the contempt it deserves and a note as to how it should be improved. Accepting less than the best encourages mediocrity; it's bad for teaching, bad for society and ultimately bad for the individual.
"Good teachers" are sensitive to the context and abilities of their students. They aim to help their students further up the ladder, maybe just one step, maybe all the way to the next landing (but they never mix their metaphors).
Sometimes that means throwing back crap with contempt. Sometimes it means accepting crap because of the value mixed in with it.
If you stick to one style of teaching, you limit yourself to one class of student. This is probably inevitable for the individual teacher, but should not be inevitable for a community of teachers. Now if only we had a community of teachers rather than a community of practitioners...
Quoted 6 lines
The constructive way to respond is to explain that this patch doesn't add value, so it's not really of the calibre that we're looking for, but then pull out one of the longstanding problems in a related area (or sometimes something you just spotted looking at the code again) and ask if the person would care to have a crack at that.
Certainly *a* constructive way to respond!
Thanks,
NeilBrown
Quoted 32 lines · Josh Triplett
Quoted 5 lines · Zefan Li
Quoted 4 lines
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
Quoted 8 lines
Do we really have this issue?
If we are encouraging more people to get involved in kernel contribution, we'll sure occasionally see some patches with little value, but I don't think we are suffering from this.
And When we see a patch of this kind, it won't take us much time to tell the newbie why the patch isn't appropriate, and then he probably won't do this again.
That's exactly the kind of thing that we *shouldn't* do.
Think about that from the new contributor's perspective. They've made a change to the kernel that has a small but non-zero value. They've just managed to work out how to jump through all the hoops needed to prepare and submit it properly for the kernel, through some combination of reading, lurking, and mentorship. And the first response they see is a maintainer like you saying "please don't send this kind of patch".
Yeah, they probably won't do that again. Congratulations, you defeated the newbie and thwarted their evil maintainer-time-wasting scheme! Hail the conquering hero; insert victory fanfare here. If you and others keep up that vigilance, perhaps one day all maintainers can rest easy, knowing they'll never again have to deal with new contributors.
</sarcasm>
Quoted 9 lines
It's perfectly reasonable to tell someone that, since they've gotten the hang of sending kernel patches, they should move on to more substantial changes, and leave simpler fixes to other potential new contributors. But that's different than telling them their patch is unwelcome.
(If someone sends in a patch that's actively wrong, sure, go right ahead and tell them what's wrong with it. But there's a difference between "wrong" and just "not that important".)
I was saying zero-value patches like whitespace cleanups but not small-but-non-zero ones.
And I didn't mean we should just close the doors to them. I should have said this "tell the newbie why the patch isn't approriate and ask him if he's interested in working on some more valuable things"
Quoted 13 lines · Jiri Kosina
On Fri, 17 Jul 2015, Steven Rostedt wrote:
[ ... snip ... ]
Quoted 2 lines
But that was an exception because the code submitted was really worth while
This really made me wonder. Maybe we should really focus on why such ocasions need to be pointed out as exceptions.
Is it that Linux kernel development got hyped so much that everyone wants to have that bullet in his CV, no matter how stupid the submitted patch would be?
Quoted 5 lines
If so, what should we do to change it?
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
I second. I think we concentrate too much on contribution and not enough on useful contribution.
Quoted 4 lines
Should we stop publishing all the statistics? I believe there is no question that those are one of the primary drivers of useless submissions. Once maintainers get DoSed by submissions of wrong and/or useless patches that eat non-negligible amount of their time, we're in trouble.
I'm not sure it's just the stats. We also have to be careful about negative perceptions, so I don't think we want to go around highlighting bad patches. There are a couple of patch sets that are draining review talent from my point of view: the mechanical one file at a time fixing X. I think we need someone to be the gatekeeper and review and apply the script in one go. And perhaps we should call the other "small patches which don't fix bugs" ... I'm less sure what to do about these.
At the other end of the scale, perhaps we should be doing more to recognise good contributions. Greg suggested prizes for first contributions, but what about in addition one more, say for best bug fix of the week (or month depending on who's running it and how much time it sucks)? We could have the maintainers nominate ones they think are good and whoever's running this picks the best.
James
Quoted 28 lines · James Bottomley
Quoted 13 lines · Jiri Kosina
On Fri, 17 Jul 2015, Steven Rostedt wrote:
[ ... snip ... ]
Quoted 2 lines
But that was an exception because the code submitted was really worth while
This really made me wonder. Maybe we should really focus on why such ocasions need to be pointed out as exceptions.
Is it that Linux kernel development got hyped so much that everyone wants to have that bullet in his CV, no matter how stupid the submitted patch would be?
Quoted 5 lines
If so, what should we do to change it?
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
I second. I think we concentrate too much on contribution and not enough on useful contribution.
Quoted 4 lines
Should we stop publishing all the statistics? I believe there is no question that those are one of the primary drivers of useless submissions. Once maintainers get DoSed by submissions of wrong and/or useless patches that eat non-negligible amount of their time, we're in trouble.
Quoted 7 lines
I'm not sure it's just the stats. We also have to be careful about negative perceptions, so I don't think we want to go around highlighting bad patches. There are a couple of patch sets that are draining review talent from my point of view: the mechanical one file at a time fixing X. I think we need someone to be the gatekeeper and review and apply the script in one go. And perhaps we should call the other "small patches which don't fix bugs" ... I'm less sure what to do about these.
If there really is a problem that some maintainer is getting inundated with patches addressing unimportant cosmetic issues, could it be a good idea to:
* Fix the code and get it over with,
* Drop the code from the kernel, if no one uses it, or
* Put a comment in the file saying that the file is no longer being actively developed and only bug fixes will be accepted.
julia
Quoted 40 lines · Julia Lawall
Quoted 28 lines · James Bottomley
Quoted 13 lines · Jiri Kosina
On Fri, 17 Jul 2015, Steven Rostedt wrote:
[ ... snip ... ]
Quoted 2 lines
But that was an exception because the code submitted was really worth while
This really made me wonder. Maybe we should really focus on why such ocasions need to be pointed out as exceptions.
Is it that Linux kernel development got hyped so much that everyone wants to have that bullet in his CV, no matter how stupid the submitted patch would be?
Quoted 5 lines
If so, what should we do to change it?
I.e. I might propose a a slightly controversial topic, going a bit the other direction than the whole "motivating newcomers" discussion: how to get rid of useless submissions that are slowing maintainers down?
I second. I think we concentrate too much on contribution and not enough on useful contribution.
Quoted 4 lines
Should we stop publishing all the statistics? I believe there is no question that those are one of the primary drivers of useless submissions. Once maintainers get DoSed by submissions of wrong and/or useless patches that eat non-negligible amount of their time, we're in trouble.
Quoted 7 lines
I'm not sure it's just the stats. We also have to be careful about negative perceptions, so I don't think we want to go around highlighting bad patches. There are a couple of patch sets that are draining review talent from my point of view: the mechanical one file at a time fixing X. I think we need someone to be the gatekeeper and review and apply the script in one go. And perhaps we should call the other "small patches which don't fix bugs" ... I'm less sure what to do about these.
Quoted 8 lines
If there really is a problem that some maintainer is getting inundated with patches addressing unimportant cosmetic issues, could it be a good idea to:
* Fix the code and get it over with,
* Drop the code from the kernel, if no one uses it, or
* Put a comment in the file saying that the file is no longer being actively developed and only bug fixes will be accepted.
I agree with this. If your subsystem is constantly getting hit with coding style cleanups that you don't want (i.e. SCSI), put something in the top of the file that says "don't clean up the style".
Of course it will be ignored (like pci_ids.h), but then you can write a simple script that just rejects such patches with a "Sorry, but please read the top of the file" rejection notice.
There, annoying patches taken care of.
greg k-h
Quoted 4 lines · Greg KH
Quoted 4 lines
If there really is a problem that some maintainer is getting inundated with patches addressing unimportant cosmetic issues, could it be a good idea to:
Quoted 9 lines
Quoted 4 lines
* Fix the code and get it over with,
* Drop the code from the kernel, if no one uses it, or
* Put a comment in the file saying that the file is no longer being actively developed and only bug fixes will be accepted.I agree with this. If your subsystem is constantly getting hit with coding style cleanups that you don't want (i.e. SCSI), put something in the top of the file that says "don't clean up the style".
How about a cleanup tag in MAINTAINERS ? Then checkpatch could warn if it is used on a file tagged as do-not-clean, and every maintainer could set preferences as desired.
Something like
C: yes
C: limited (prior to functional changes only)
C: no
Either limited or yes could be the default.
The "Obsolete" status presumably implies that cleanups are not desired, and checkpatch could issue a warning if it is run on an obsolete file or subsystem.
Guenter
Quoted 26 lines · Guenter Roeck
Quoted 4 lines · Greg KH
Quoted 4 lines
If there really is a problem that some maintainer is getting inundated with patches addressing unimportant cosmetic issues, could it be a good idea to:
Quoted 9 lines
Quoted 4 lines
* Fix the code and get it over with,
* Drop the code from the kernel, if no one uses it, or
* Put a comment in the file saying that the file is no longer being actively developed and only bug fixes will be accepted.I agree with this. If your subsystem is constantly getting hit with coding style cleanups that you don't want (i.e. SCSI), put something in the top of the file that says "don't clean up the style".
How about a cleanup tag in
MAINTAINERS? Then checkpatch could warn if it is used on a file tagged as do-not-clean, and every maintainer could set preferences as desired.Something like
C: yes
C: limited (prior to functional changes only)
C: no
Quoted 5 lines
Either limited or yes could be the default.
The "Obsolete" status presumably implies that cleanups are not desired, and checkpatch could issue a warning if it is run on an obsolete file or subsystem.
Ugh, let's stop trying to add more flags to MAINTAINERS that no one will notice and will get out of date and be a pain to maintain over time.
Is this really such a major issue? If you don't want cleanup patches, just politely refuse them and point people at drivers/staging/ where I will gladly take them. It's not tough at all.
Or better yet, take Julia's advice, and just fix up your subsystem to not need these patches at all. That should take all of an afternoon's worth of effort at most, drivers/scsi/ notwithstanding, that beast is horrid...
thanks,
greg k-h
Quoted 27 lines · Greg KH
Quoted 26 lines · Guenter Roeck
Quoted 4 lines · Greg KH
Quoted 4 lines
If there really is a problem that some maintainer is getting inundated with patches addressing unimportant cosmetic issues, could it be a good idea to:
Quoted 9 lines
Quoted 4 lines
* Fix the code and get it over with,
* Drop the code from the kernel, if no one uses it, or
* Put a comment in the file saying that the file is no longer being actively developed and only bug fixes will be accepted.I agree with this. If your subsystem is constantly getting hit with coding style cleanups that you don't want (i.e. SCSI), put something in the top of the file that says "don't clean up the style".
How about a cleanup tag in
MAINTAINERS? Then checkpatch could warn if it is used on a file tagged as do-not-clean, and every maintainer could set preferences as desired.Something like
C: yes
C: limited (prior to functional changes only)
C: no
Quoted 9 lines
Quoted 5 lines
Either limited or yes could be the default.
The "Obsolete" status presumably implies that cleanups are not desired, and checkpatch could issue a warning if it is run on an obsolete file or subsystem.
Ugh, let's stop trying to add more flags to
MAINTAINERSthat no one will notice and will get out of date and be a pain to maintain over time.
It would be noticed since checkpatch would use it. And maintainers would have interest to keep it up to date, especially those who dislike cleanup patches.
Quoted 4 lines
Is this really such a major issue? If you don't want cleanup patches, just politely refuse them and point people at
drivers/staging/where I will gladly take them. It's not tough at all.
It isn't tough or an issue for me, but I don't normally refuse cleanup patches either.
Quoted 5 lines
Or better yet, take Julia's advice, and just fix up your subsystem to not need these patches at all. That should take all of an afternoon's worth of effort at most,
drivers/scsi/notwithstanding, that beast is horrid...
Yes, that is what I am doing once in a while, if I need a timeout from other work. Since I don't mind cleanup patches, so I would set the tag to 'yes' for all files where I am listed as maintainer. But other maintainers do actively reject cleanup patches, sometimes with less then friendly words.
Without a tag, the result is to discourage cleanup patches in general, or what I would call the lowest common denominator. While I understand and accept that other maintainers dislike cleanup patches, I don't see why I should have to suffer the consequences.
Guenter
Quoted 8 lines · Steven Rostedt
Quoted 3 lines · On Sat, 18 Jul 2015 11:42:28 +1000 NeilBrown <[email protected]> wrote:
We talk a lot about creating tooling to help newbies submit perfect patches. Maybe we need to spend more time creating tooling to help old timers accept imperfect patches.
+1
+10
I do some work in gerrit, where patches are "automatically" merged by the submitter after being approved by reviewers. It is a real hassle because every last nit has to be removed for the automatic merge to work, and the nits are hard for non-experts to discover. The environment would feel much friendlier if there were a human maintainer involved who could say "this patch belongs on branch X instead," or "this patch needs to be rebased to Y," or whatever. These are trivial for the right person to do, but often hard for the submitter.
On the maintainer side, I spend a lot of time trying to coordinate between patchwork (as a to-do list) and mutt (for reviewing and applying patches). It's a lot of pointing and clicking for not much real value. I know I could benefit from learning how other people do this, because I'm sure I'm not doing it the best way.
Bjorn
Quoted 6 lines
Quoted 4 lines
Is this really such a major issue? If you don't want cleanup patches, just politely refuse them and point people at
drivers/staging/where I will gladly take them. It's not tough at all.It isn't tough or an issue for me, but I don't normally refuse cleanup patches either.
Politely pointing people at staging is an OK strategy, but I think newbies would really prefer to know in advance that their patch has no chance of being accepted.
julia
Quoted 19 lines
Quoted 5 lines
Or better yet, take Julia's advice, and just fix up your subsystem to not need these patches at all. That should take all of an afternoon's worth of effort at most,
drivers/scsi/notwithstanding, that beast is horrid...Yes, that is what I am doing once in a while, if I need a timeout from other work. Since I don't mind cleanup patches, so I would set the tag to 'yes' for all files where I am listed as maintainer. But other maintainers do actively reject cleanup patches, sometimes with less then friendly words.
Without a tag, the result is to discourage cleanup patches in general, or what I would call the lowest common denominator. While I understand and accept that other maintainers dislike cleanup patches, I don't see why I should have to suffer the consequences.
Guenter
Quoted 11 lines · Julia Lawall
Quoted 6 lines
Quoted 4 lines
Is this really such a major issue? If you don't want cleanup patches, just politely refuse them and point people at
drivers/staging/where I will gladly take them. It's not tough at all.It isn't tough or an issue for me, but I don't normally refuse cleanup patches either.
Politely pointing people at staging is an OK strategy, but I think newbies would really prefer to know in advance that their patch has no chance of being accepted.
Very much agreed.
Guenter
Quoted 26 lines · Guenter Roeck
Quoted 4 lines · Greg KH
Quoted 4 lines
If there really is a problem that some maintainer is getting inundated with patches addressing unimportant cosmetic issues, could it be a good idea to:
Quoted 9 lines
Quoted 4 lines
* Fix the code and get it over with,
* Drop the code from the kernel, if no one uses it, or
* Put a comment in the file saying that the file is no longer being actively developed and only bug fixes will be accepted.I agree with this. If your subsystem is constantly getting hit with coding style cleanups that you don't want (i.e. SCSI), put something in the top of the file that says "don't clean up the style".
How about a cleanup tag in
MAINTAINERS? Then checkpatch could warn if it is used on a file tagged as do-not-clean, and every maintainer could set preferences as desired.Something like
C: yes
C: limited (prior to functional changes only)
C: no
Quoted 5 lines
Either limited or yes could be the default.
The "Obsolete" status presumably implies that cleanups are not desired, and checkpatch could issue a warning if it is run on an obsolete file or subsystem.
This seems like a good idea. Maybe get_maintainers could add a line about this somehow too for people who do cleanups that are not inspired by checkpatch.
This does assume that the decision is mostly by maintainer rather than by file.
julia
Quoted 3 lines · James Bottomley
the mechanical one file at a time fixing
X. I think we need someone to be the gatekeeper and review and apply the script in one go.
I often find myself writing this kind of tree-wide fix, and I find it frustrating that it can't get merged as a unit; that would avoid the inevitable pile of merge conflicts, as well. For anything that can be reliably applied as a script, I'd love to see it actually run as a script and the result committed.
- Josh Triplett
Quoted 10 lines · Josh Triplett
Quoted 3 lines · James Bottomley
the mechanical one file at a time fixing
X. I think we need someone to be the gatekeeper and review and apply the script in one go.I often find myself writing this kind of tree-wide fix, and I find it frustrating that it can't get merged as a unit; that would avoid the inevitable pile of merge conflicts, as well. For anything that can be reliably applied as a script, I'd love to see it actually run as a script and the result committed.
Can you propose a mechanism? We already have the trivial tree ... should we have the script tree, and would you volunteer to maintain it? Probably we'd run the script just after the merge window closes, so it would likely be a late merging tree.
James
Quoted 12 lines · James Bottomley
Quoted 10 lines · Josh Triplett
Quoted 3 lines · James Bottomley
the mechanical one file at a time fixing
X. I think we need someone to be the gatekeeper and review and apply the script in one go.I often find myself writing this kind of tree-wide fix, and I find it frustrating that it can't get merged as a unit; that would avoid the inevitable pile of merge conflicts, as well. For anything that can be reliably applied as a script, I'd love to see it actually run as a script and the result committed.
Quoted 4 lines
Can you propose a mechanism? We already have the trivial tree ... should we have the script tree, and would you volunteer to maintain it? Probably we'd run the script just after the merge window closes, so it would likely be a late merging tree.
We have done that a few times, with Linus actually running the script for himself just after the last pull for -rc1.
I think last time he may have said "never again", but perhaps that was the nature of the changes (the include/uapi moves iirc) rather than the act of running a script per se.
I'm not sure we need a way to handle such scripted changes in bulk. They are relatively infrequent, aren't they?
The problem is that a lot of these really do need to be checked by a real human after the scripted change (even Coccinelle-type changes) is made. And thus we can't easily just let a script run free.
Signature · 2 lines
David Woodhouse Open Source Technology Centre [email protected] Intel Corporation
Quoted 25 lines · David Woodhouse
Quoted 12 lines · James Bottomley
Quoted 10 lines · Josh Triplett
Quoted 3 lines · James Bottomley
the mechanical one file at a time fixing
X. I think we need someone to be the gatekeeper and review and apply the script in one go.I often find myself writing this kind of tree-wide fix, and I find it frustrating that it can't get merged as a unit; that would avoid the inevitable pile of merge conflicts, as well. For anything that can be reliably applied as a script, I'd love to see it actually run as a script and the result committed.
Quoted 4 lines
Can you propose a mechanism? We already have the trivial tree ... should we have the script tree, and would you volunteer to maintain it? Probably we'd run the script just after the merge window closes, so it would likely be a late merging tree.
We have done that a few times, with Linus actually running the script for himself just after the last pull for -rc1.
I think last time he may have said "never again", but perhaps that was the nature of the changes (the
include/uapimoves iirc) rather than the act of running a script per se.
Quoted 6 lines
I'm not sure we need a way to handle such scripted changes in bulk. They are relatively infrequent, aren't they?
The problem is that a lot of these really do need to be checked by a real human after the scripted change (even Coccinelle-type changes) is made. And thus we can't easily just let a script run free.
Agree ... that's why we need a responsible maintainer, and I believe it would be an even more onerous task than running the trivial tree.
James
Quoted 2 lines · James Bottomley
Agree ... that's why we need a responsible maintainer, and I believe it would be an even more onerous task than running the trivial tree.
I think any scripted change like this would need to come *from* a responsible maintainer, not *through* one. I'm not sure we really need a 'process' for it other than someone with sufficient credibility persuading Linus to run the script.
Alternatively, it isn't *that* hard for someone like Josh (who was the one who said he often finds himself doing this kind of thing) to create a git tree which runs the script *regularly* on the tip of Linus' tree (or linux-next), creating a new version of the commit which can be pulled at that moment.
Then it should just be case of of asking Stephen to "put this tree last in linux-next", and Linus to "pull this one last, right before releasing -rc1". And getting the timing right for the script to run.
Signature · 2 lines
David Woodhouse Open Source Technology Centre [email protected] Intel Corporation
Quoted 4 lines
Then it should just be case of of asking Stephen to "put this tree last in linux-next", and Linus to "pull this one last, right before releasing -rc1". And getting the timing right for the script to run.
This makes git-blame less useful, and that's one of the reasons some maintainers don't like trivial cleanups.
Quoted 7 lines · Zefan Li
Quoted 4 lines
Then it should just be case of of asking Stephen to "put this tree last in linux-next", and Linus to "pull this one last, right before releasing -rc1". And getting the timing right for the script to run.
This makes git-blame less useful, and that's one of the reasons some maintainers don't like trivial cleanups.
Josh was asking about useful tree-wide changes. How does that mae git blame less useful than doing the changes one by one?
And actually couldn't git blame be made to work better?
julia
Quoted 7 lines · On Tue, 21 Jul 2015 10:00:33 +0800 Zefan Li <[email protected]> wrote:
Quoted 4 lines
Then it should just be case of of asking Stephen to "put this tree last in linux-next", and Linus to "pull this one last, right before releasing -rc1". And getting the timing right for the script to run.
This makes git-blame less useful, and that's one of the reasons some maintainers don't like trivial cleanups.
Sounds like we need to propose an enhancement to "git-blame"...
NeilBrown
Quoted 7 lines · On Tue, 21 Jul 2015 18:54:36 +1000 NeilBrown <[email protected]> wrote:
Quoted 5 lines · On Tue, 21 Jul 2015 10:00:33 +0800 Zefan Li <[email protected]> wrote:
Quoted 4 lines
Then it should just be case of of asking Stephen to "put this tree last in linux-next", and Linus to "pull this one last, right before releasing -rc1". And getting the timing right for the script to run.
Quoted 5 lines
Quoted 2 lines
This makes git-blame less useful, and that's one of the reasons some maintainers don't like trivial cleanups.
Sounds like we need to propose an enhancement to "git-blame"...
No need. I use git blame all the time. Trivial patches don't bother me.
$ git blame foo.c
$ git show abc123
Sees that it's a trivial fix
$ git blame abc123~1 foo.c
$ git show def890
More changes I don't care about
$ git blame def890~1 foo.c
$ git show cde456
Ah! that's the change I was looking for!
-- Steve
Quoted 28 lines · Steven Rostedt
Quoted 7 lines · On Tue, 21 Jul 2015 18:54:36 +1000 NeilBrown <[email protected]> wrote:
Quoted 5 lines · On Tue, 21 Jul 2015 10:00:33 +0800 Zefan Li <[email protected]> wrote:
Quoted 4 lines
Then it should just be case of of asking Stephen to "put this tree last in linux-next", and Linus to "pull this one last, right before releasing -rc1". And getting the timing right for the script to run.
Quoted 5 lines
Quoted 2 lines
This makes git-blame less useful, and that's one of the reasons some maintainers don't like trivial cleanups.
Sounds like we need to propose an enhancement to "git-blame"...
No need. I use git blame all the time. Trivial patches don't bother me.
$ git blame foo.c$ git show abc123Sees that it's a trivial fix
$ git blame abc123~1 foo.c$ git show def890
Quoted 7 lines
More changes I don't care about
$ git blame def890~1 foo.c$ git show cde456Ah! that's the change I was looking for!
I don't know if you'd find this more work or less, but I use "git log -p foo.c" for this instead of git blame. Unless there's been a rename or a move between files, one invocation is usually enough.
Bjorn
Quoted 5 lines · On Wed, 22 Jul 2015 08:57:34 -0500 Bjorn Helgaas <[email protected]> wrote:
Quoted 1 line
Ah! that's the change I was looking for!
I don't know if you'd find this more work or less, but I use "git log -p
foo.c" for this instead of git blame. Unless there's been a rename or a move between files, one invocation is usually enough.
I've used "git log -p foo.c" before, but I find that some of my files I work with, that is way too much info. Especially, when the commit I'm looking for happens to be years old. I use the log -p for when I know the change has been recent.
-- Steve
Quoted 6 lines · Steven Rostedt
Quoted 2 lines · On Wed, 22 Jul 2015 08:57:34 -0500 Bjorn Helgaas <[email protected]> wrote:
Quoted 1 line
Ah! that's the change I was looking for!
Quoted 8 lines
Quoted 3 lines
I don't know if you'd find this more work or less, but I use "git log -p
foo.c" for this instead of git blame. Unless there's been a rename or a move between files, one invocation is usually enough.I've used "git log -p
foo.c" before, but I find that some of my files I work with, that is way too much info. Especially, when the commit I'm looking for happens to be years old. I use the log -p for when I know the change has been recent.
I think what we need is a git log --line <name> <path> which would track the commits that touched a given line in <path> (hopefully even across renames). It shouldn't be too hard to come up with that.
James
Quoted 11 lines · James Bottomley
Quoted 10 lines · Steven Rostedt
Quoted 5 lines · On Wed, 22 Jul 2015 08:57:34 -0500 Bjorn Helgaas <[email protected]> wrote:
Quoted 1 line
Ah! that's the change I was looking for!
I don't know if you'd find this more work or less, but I use "git log -p
foo.c" for this instead of git blame. Unless there's been a rename or a move between files, one invocation is usually enough.
Quoted 8 lines
Quoted 4 lines
I've used "git log -p
foo.c" before, but I find that some of my files I work with, that is way too much info. Especially, when the commit I'm looking for happens to be years old. I use the log -p for when I know the change has been recent.I think what we need is a git log --line <name> <path> which would track the commits that touched a given line in <path> (hopefully even across renames). It shouldn't be too hard to come up with that.
Well, duh, we do, it's git log -L ... I take it no-one uses it because like me, no-one knows about it?
James
Quoted 3 lines · On Wed, 22 Jul 2015 07:42:01 -0700 James Bottomley…
I think what we need is a git log --line <name> <path> which would track the commits that touched a given line in <path> (hopefully even across renames). It shouldn't be too hard to come up with that.
That may not be trivial. It would have to keep track of changes before the line, to match the line in previous commits. What happens if the line completely changes, or is in a complete rewrite of that code. I doubt it will be smart enough to follow a single line. Perhaps a range would be better?
-- Steve
Quoted 7 lines · Steven Rostedt
Quoted 3 lines · On Wed, 22 Jul 2015 07:42:01 -0700 James Bottomley…
I think what we need is a git log --line <name> <path> which would track the commits that touched a given line in <path> (hopefully even across renames). It shouldn't be too hard to come up with that.
Quoted 5 lines
That may not be trivial. It would have to keep track of changes before the line, to match the line in previous commits. What happens if the line completely changes, or is in a complete rewrite of that code. I doubt it will be smart enough to follow a single line. Perhaps a range would be better?
I assume you missed the follow up? It does exist: git log -L
It will follow a single line, a line range or a regex delimited search set.
James
Quoted 20 lines · Steven Rostedt
Quoted 7 lines · On Tue, 21 Jul 2015 18:54:36 +1000 NeilBrown <[email protected]> wrote:
Quoted 5 lines · On Tue, 21 Jul 2015 10:00:33 +0800 Zefan Li <[email protected]> wrote:
Quoted 4 lines
Then it should just be case of of asking Stephen to "put this tree last in linux-next", and Linus to "pull this one last, right before releasing -rc1". And getting the timing right for the script to run.
Quoted 5 lines
Quoted 2 lines
This makes git-blame less useful, and that's one of the reasons some maintainers don't like trivial cleanups.
Sounds like we need to propose an enhancement to "git-blame"...
No need. I use git blame all the time. Trivial patches don't bother me.
$ git blame foo.c
Quoted 7 lines
$ git show abc123Sees that it's a trivial fix
$ git blame abc123~1 foo.c$ git show def890
If you use vim, try vim-fugitive for this. While editing a file, :Gblame to get the blame info. Hit o in the blame window to open a commit, showing the commit message and patch, automatically jumping to the patch line that changed the line you're looking at. If that's not the commit you want, hit P in the blame window to re-blame from the parent of that commit.
- Josh Triplett
Quoted 15 lines · David Woodhouse
Quoted 2 lines · James Bottomley
Agree ... that's why we need a responsible maintainer, and I believe it would be an even more onerous task than running the trivial tree.
I think any scripted change like this would need to come *from* a responsible maintainer, not *through* one. I'm not sure we really need a 'process' for it other than someone with sufficient credibility persuading Linus to run the script.
Alternatively, it isn't *that* hard for someone like Josh (who was the one who said he often finds himself doing this kind of thing) to create a git tree which runs the script *regularly* on the tip of Linus' tree (or linux-next), creating a new version of the commit which can be pulled at that moment.
Quoted 3 lines
Then it should just be case of of asking Stephen to "put this tree last in linux-next", and Linus to "pull this one last, right before releasing -rc1". And getting the timing right for the script to run.
I ran into quite a bit of delay / coordination through another types of tree-wide changes recently: tree wide collateral evolutions which affect more than one subsystem. One of the issues with this is such type of changes may end up having 1-2 release delays before being complete unless the stars align and everone can get in sync and agree for all changes to go through one tree. I'm sure this is not a new thing either, but with tools like Coccinelle I do suspect the amount of work to do this has reduced and as such we should be able to more easily make these changes. What I found was that our pipes were not as smooth to handle these types of changes when needed, even if everyone was in total agreement.
I proposed a linux-oven tree [0], pricicely as David describes, which can be used after all trees are merged. So not only would it be useful for scraped cleanups but also tree wide collateral evolutions which span multiple subsystems. If such a tree existed and folks knew such maintainer would go through proper dilligence for testing, review, vetting from maintainers I think it would make both scripted changes and tree wide collateral evolutions easier to manage. If done through a separate tree Linus would also not need to be involved, instread the onus of correcting patches lies on the developers submitting to the tree and the maintainer.
[0] http://lkml.kernel.org/r/[email protected]
Luis
Quoted 6 lines · James Bottomley
At the other end of the scale, perhaps we should be doing more to recognise good contributions. Greg suggested prizes for first contributions, but what about in addition one more, say for best bug fix of the week (or month depending on who's running it and how much time it sucks)? We could have the maintainers nominate ones they think are good and whoever's running this picks the best.
I think this is a great idea, and I'd be willing to help work through the Linux Foundation on prizes and coordination. One thing which I can possibly put in the prize "pool", is free admission to ELC or ELC Europe (maybe even some paid travel expenses) I can also talk to companies about donations for prizes (we do this for our closing game session at events anyway).
-- Tim
Quoted 15 lines · On Fri, 2015-07-17 at 13:48 -0700, [email protected] wrote:
Quoted 9 lines · Steven Rostedt
Quoted 7 lines · On Fri, 17 Jul 2015 13:24:12 -0700 [email protected] wrote:
If your biggest hangup as a maintainer is that people send you patches that don't have variables sorted in some particular order, perhaps you should get out of kernel development and get into bike shed colorimetry consulting. We have enough problems getting quality patches by the metrics that *actually* correlate to quality. And as others have pointed out in this thread, many people produce patches across numerous subsystems.
Quoted 4 lines
I personally don't have any issue with my own idiosyncrasies not being met. They are usually minor, and I'll fix up the patch (and document it in the change log). These minor idiosyncrasies make maintaining code easier.
Quoted 4 lines
That's perfectly reasonable. If you want to take the time making the code in your area conform to additional requirements above and beyond those of the kernel as a whole, go for it. I appreciate that you don't ask others to do it for you.
I tend to do the same. I'll fairly consistently fix up (C) to ©, u to µ, and found myself bitching at David Howells for using 'sec' instead of § the other day. This far into the 21st century, there really isn't any excuse for people not doing that, but I don't reject patches because of it.
I do *sometimes* make people fix things to say 'KiB', 'MiB' etc. for themselves if they've sent me something that is plain wrong and using the powers-of-ten versions inappropriately. But often I just fix that up for myself too.
Signature · 2 lines
David Woodhouse Open Source Technology Centre [email protected] Intel Corporation
Quoted 1 line · David Woodhouse
I tend to do the same. I'll fairly consistently fix up (C) to ©
Slightly OT, but I'd suggest you be careful with that. I've heard lawyers saying that those two are unfortunately not legally equivalent.
Signature · 2 lines
Jiri Kosina SUSE Labs
Quoted 6 lines · Jiri Kosina
Quoted 1 line · David Woodhouse
I tend to do the same. I'll fairly consistently fix up (C) to ©
Slightly OT, but I'd suggest you be careful with that. I've heard lawyers saying that those two are unfortunately not legally equivalent.
Just to note that under the Berne convention and in most jurisdictions, neither is actually necessary to acquire copyright.
James
Quoted 10 lines · James Bottomley
Quoted 6 lines · Jiri Kosina
Quoted 1 line · David Woodhouse
I tend to do the same. I'll fairly consistently fix up (C) to ©
Slightly OT, but I'd suggest you be careful with that. I've heard lawyers saying that those two are unfortunately not legally equivalent.
Just to note that under the Berne convention and in most jurisdictions, neither is actually necessary to acquire copyright.
Indeed. And although I *have* heard rumours of non-equivalence in the past, it was always the fake (c) version that wasn't functional, while the real © sign was.
Signature · 1 line
dwmw2
Quoted 22 lines · David Woodhouse
Quoted 15 lines · On Fri, 2015-07-17 at 13:48 -0700, [email protected] wrote:
Quoted 9 lines · Steven Rostedt
Quoted 7 lines · On Fri, 17 Jul 2015 13:24:12 -0700 [email protected] wrote:
If your biggest hangup as a maintainer is that people send you patches that don't have variables sorted in some particular order, perhaps you should get out of kernel development and get into bike shed colorimetry consulting. We have enough problems getting quality patches by the metrics that *actually* correlate to quality. And as others have pointed out in this thread, many people produce patches across numerous subsystems.
Quoted 4 lines
I personally don't have any issue with my own idiosyncrasies not being met. They are usually minor, and I'll fix up the patch (and document it in the change log). These minor idiosyncrasies make maintaining code easier.
Quoted 4 lines
That's perfectly reasonable. If you want to take the time making the code in your area conform to additional requirements above and beyond those of the kernel as a whole, go for it. I appreciate that you don't ask others to do it for you.
Quoted 5 lines
I tend to do the same. I'll fairly consistently fix up (C) to ©, u to µ, and found myself bitching at David Howells for using 'sec' instead of § the other day. This far into the 21st century, there really isn't any excuse for people not doing that, but I don't reject patches because of it.
A further off-topic note: these letters may still cause troubles even in the 21th century because of their width definition: East Asian Ambiguous. It can be rendered as a wide character depending on the system. So, if the comment text is written with the assumption of fixed width glyph, the alignment may be broken.
Takashi
Quoted 11 lines · Steven Rostedt
As I know a few maintainers that like the "reverse-xmas-tree" order, perhaps we could add that to CodingStyle in a section of:
--- Some Maintainer's prefer these styles ---
These are some extra styles that maintainers prefer. Some are strict about these, others may not care. It doesn't hurt to add them.
Because things like reverse x-mas tree order isn't something people are against doing. But some may not care if you do or don't. So listing all the things that a few maintainers share, may be good.
OK - I had never even heard of reverse christmas-tree order before this discussion, so I did some research. For those unfamiliar, it is sorting things by line length (most commonly include file lines and variable declaration lines), from longest to shortest. This has the effect of somewhat randomizing these items relative to each other, which reduces the probability of patch conflicts.
I think everyone has looked at where to put a new include statement, or local variable declaration, and wondered where the best spot is. The reverse-christmas-tree order rule provides a definitive answer for this question, as well as decreases the chance of patch conflicts. What's not to love?
Well, I think this is exactly the wrong solution to the problem this rule is trying to solve. First, this adds one more rule (which only a few maintainers appear to care about) to the already lengthy "death-by-a-thousand-cuts" patch submission process which we've been discussing in this thread. It's a trivial rule that's easy to follow, and it reduces patch conflicts, which are a very real maintainer burden to resolve. But still it adds to the submission process incrementally.
Also, it doesn't actually solve all patch conflicts on these lines - it just decreases the probability of them. And it does so in a way that sacrifices human logic and readability to make the code easier for tools to process. Isn't this exactly backwards?
I've long thought that patch or wiggle should be able to ignore context lines for include statements. It might be possible with some work to handle the variable declaration case as well. I'll either work on this myself, or (this is more my style ;-) ) propose funding a project through the Linux Foundation to work on this.
I'm very interested in this topic of reducing the process of submitting patches and easing maintainer load through automation. Part of this would be to determine what things maintainers actually spend their time responding to, that can be addressed through automation. I believe this discussion has been very helpful to highlight some issues that at least some maintainers have. But maybe a brainstorming session at the summit would give more areas to consider working on.
-- Tim
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
_phaseof themoon_and they really should have known better.
Since when is Linus opening up the merge window by moon phases? :P
Peter
Quoted 15 lines · Mark Brown
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 9 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.
I tried both (ping and resend). In either case the response depends on the maintainer. Some will accept either, some will say you should have res-sent the patch if you sent a ping, some will tell you that you should have pinged if you re-sent it. Depending on the maintainer the response can be pretty strong.
It would be great to have a single well defined and documented mechanism to avoid the "whatever you do is wrong" response.
Guenter
Quoted 8 lines · On Fri, 17 Jul 2015 09:10:25 -0700 Guenter Roeck <[email protected]> wrote:
I tried both (ping and resend). In either case the response depends on the maintainer. Some will accept either, some will say you should have res-sent the patch if you sent a ping, some will tell you that you should have pinged if you re-sent it. Depending on the maintainer the response can be pretty strong.
It would be great to have a single well defined and documented mechanism to avoid the "whatever you do is wrong" response.
Or at least a polite reply to have them do it the other way.
"Hi! Sorry, I've been busy and haven't had time to review your patch. Can you please resend the patch to me again, my inbox corrupted your old one"
Sure the corruption message may be a lie, but at least it will keep them from saying "why not use what I already sent you".
-- Steve
Quoted 10 lines · On Friday 17 July 2015 12:23:03 Steven Rostedt wrote:
Quoted 8 lines · On Fri, 17 Jul 2015 09:10:25 -0700 Guenter Roeck wrote:
I tried both (ping and resend). In either case the response depends on the maintainer. Some will accept either, some will say you should have res-sent the patch if you sent a ping, some will tell you that you should have pinged if you re-sent it. Depending on the maintainer the response can be pretty strong.
It would be great to have a single well defined and documented mechanism to avoid the "whatever you do is wrong" response.
Quoted 7 lines
Or at least a polite reply to have them do it the other way.
"Hi! Sorry, I've been busy and haven't had time to review your patch. Can you please resend the patch to me again, my inbox corrupted your old one"
Sure the corruption message may be a lie,
"My dog ate your patch" sounds better to me. We could then have a contest to see who will come up with the best fake excuse :-)
Quoted 2 lines
but at least it will keep them from saying "why not use what I already sent you".
Signature · 3 lines
Regards, Laurent Pinchart
One week is too short. What's the rush? You still have to wait over a month to the next merge window.
I don't like [RESEND] patches. I always treat them like a process failure and investigate what went wrong. Normally in staging they are really supposed to be v2 patches with an note what changed or they are staging/media patches which are supposed to go to linux-media. Greg seldom loses patches.
Steve's people who let patches age and then silently drop them... It's less then ideal.
regards,
dan carpenter
Quoted 2 lines · On Sat, 18 Jul 2015 13:50:55 +0300 Dan Carpenter <[email protected]>…
One week is too short. What's the rush? You still have to wait over a month to the next merge window.
One ping a week is just a reminder. It doesn't fill your mailbox quickly. It doesn't mean you need to do it in that week. Also, the quicker it goes in before the merge window, the more testing it will receive.
Really, a ping once a week will bother you? The once a week was what I and a few others started to enforce when we were getting pings once a day.
-- Steve
Quoted 4 lines · Steven Rostedt
One ping a week is just a reminder. It doesn't fill your mailbox quickly. It doesn't mean you need to do it in that week. Also, the quicker it goes in before the merge window, the more testing it will receive.
It adds up pretty quickly. No argument that merging things quickly is good but having to read more content free e-mails is not going to help with that. Indeed if I'm expecting someone else to review a patch for some reason (eg, driver maintainers) a week is about the normal time I'd give for them to ack it if I'm confident in the patch myself so it's sometimes a deliberately introduced delay.
Like I say my experience as a patch submitter is that I'd be sending pings more often than not at a week whereas it's reasonably infrequent that I need to resend anything.
Quoted 3 lines
Really, a ping once a week will bother you? The once a week was what I and a few others started to enforce when we were getting pings once a day.
Yes, it does. It's far too close to the window of normal delays that happen (finding time to read larger or more complicated patches and serieses, travel, whatever) and my guess is that my response if everyone was nagging at that rate would be to treat the nags as noise and ignore them which defeats the purpose. These things only work if they're unusual.
Two weeks feels like a better lower bound to me for the point between people being "normally" busy and there being some kind of problem.
Quoted 2 lines · On Sat, 18 Jul 2015 22:29:32 +0100 Mark Brown <[email protected]> wrote:
Two weeks feels like a better lower bound to me for the point between people being "normally" busy and there being some kind of problem.
Like I have previously said. I (and others) suggest one week as a minimum. It's a general rule that we came up as the minimum (for us) that it wouldn't bother us, because we were getting pings after a day or two. This happened a number of times, and we finally ended up telling people that if you send pings less than a week we are going to ignore the patch.
If we are going to make any general rule (for adding to SubittingPatches), it should say something like "If you don't hear from a maintainer after sending a patch, it probably means they are busy. Wait at least a week (and if you don't want to annoy the maintainer too much, wait two weeks), before asking about it".
-- Steve
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
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 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 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 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
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
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
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 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 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 :-)
[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
Re: [Ksummit-discuss] checkpatch.pl stuff...
Quoted 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
Re: [Ksummit-discuss] checkpatch.pl stuff...
Quoted 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
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 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 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
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, 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
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
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