patch series vs. multiple files changed in a commit; storytelling history vs. literal creation history

I've read Documentation/SubmittingPatches, followed some of the discussion on this list, and looked over some of the recent commit history. I'm impressed by the strong culture of review that produces readable patches and commit messages, but I think there are some gaps in my understanding of the prevailing process here.

Most of the code I've worked on has been closed source, and the commit histories tend to reflect what I'd call the literal "creation history". Reading the Git history, my impression is that it reflects a different "storytelling" history. In some cases, that might be the same as the creation history, but in general the emphasis is on telling a coherent story of the changes to the other developers rather than communicating all the messy details of how you arrived at the order of that story. Is that right?

What are the Git project's rules of thumb for when to create a patch series vs. putting changes to multiple files in a single commit/patch?

As a patch series evolves before landing on an upstream branch, do you typically make corrections to the original series in new commits, or update the respective commits from the original series in a new series of analogous commits?

Matt McClure <matthewlmcclure@gmail.com> writes:

We do not try to keep records of "oops, the previous was wrong" when we can easily tell the previous was wrong. Usually such a shallow mistake that can be spotted during the review is not worth keeping.

For example, the 4 patch series I posted today had three iterations of botched attempts that were never even published. I am sure other people do the same for their initial round for their patches, and any message on this list whose subject begins with "[PATCH vN X/Y]" for N > 2 are rewritten betterment based on list feedback.

Our history tends to become a coherent story because of this.

It is a different story for more involved changes that cook in 'next' for a while and then later turns out to have flaws. We update them with follow-up fixes and at that point, we do have records of mistakes. They often are tricky cases that are worth recording, as people can later make similar kinds of mistakes in other parts of the codebase.

The early part of the history back when Linus was running the show is somewhat different; you see more reverts and rewrites. But even back then, there were more experimental changes that were rewritten than the changes that were finally committed to the history.