Hacker News Reader

Comment by spanhandler | Hacker News Reader

  Andrew Morton (7):
    updates
    more updates
    yet more updates
    still more updates
    even more updates
    some more updates
    updates

Real illuminating merge log there bud :-)

View on HN

I'm surprised this is allowed in the linux kernel. I am not familiar, but assuming these are commit messages, that's pretty damn pathetic.

These are only merges - they don't matter. The actual functional commits are excellent beyond anything you would ever find in your company VCS.

>you would ever find in your company VCS.

But why so offensively?

He raised good concerns

Because they are good commits.

He didn't raise good concerns, he got outraged after reading a HN comment and labeled "pathetic" something he knows nothing about, has no context in, and didn't even spend 5 minutes researching.

This is the correct answer. The difference between the messages I leave for myself in my local merges and my actual commits to the dev branch are night and day.

I'm not sure I'd classify what I read as "outraged" (different people express themselves in different ways, not everyone uses "pathetic" with the same vehemence or vitriol).

That said, that merge log is fairly useless. Whether it needs to be anything other than that, and who generally would see it and whether it's for the person writing it or someone else is something to be discussed, but even in the case it's mainly meant for the author to look back on, is it even succeeding in being useful in that job? I would agree that it appears pathetic, but probably pathetic in a low-cost doesn't really matter way.

I still wish people would give meaningful names to their merge commits. Together with `git log --first-parent` and the alligator [1] workflow, it can filter out the less interesting patch series to focus on the bigger picture (the fact that you added a functionality, not that it took you 53 commits changing very specific parts to do so).

[1]: https://euroquis.nl/blabla/2019/08/09/git-alligator.html

You are looking for the cover letter, a random example:

https://patchwork.freedesktop.org/series/73884/

With the current kernel development model these aren't recorded in the actual tree, though.

Why can't the same requirement be achieved using meaningful merge messages? I personally usem them.

I agree, I don't think "it's only a merge commit" is any excuse whatsoever. But I personally pretty aggressively squash my commits with "rebase -i" before merge, exactly in order for there to be not much of a "bigger picture". And I urge others to do the same as well, because no matter how many fixes there was during the development, later on everybody will ultimately care only about "what it was about in the essence?" I.e., added functionality this-and-that, or a fix, or refactoring, or maybe something new implemented (but not "active" as of yet). Small commits are nice when doing git bisect, but given your code is not a complete trash, it is properly tested and refactoring (which is usually the biggest code change anyway) is separated from the "meaningful" changes, there's no much use in them after a year.

So the best use I've seen for the merge commits are bugtracker task IDs and such.

Have you ever worked in a team context where you needed to share a cherry picked commit between branches? Or e.g. between develop and a patch release?

People actually allow this!?

It's a standard practise:

1. Create a bug fix on the main development branch. eg "master" or equivalent.

This ensures the bug is "resolved" for all new builds and future releases.

2. Apply the fix to the supported release branches. eg v3.12.x, v3.11.x, etc.

This ensures the bug is "resolved" for all new point releases created from those release branches. eg v3.12.1, v3.12.2, etc.

I'm on a project and it's the opposite. Full releases every... 2 months give or take, but every... week or two, there's a round up of 'critical' issues, and you're expected to take just those issues from 'develop' (or somewhere) and get them over in to a 'release' branch of the current released code. I now tend to keep local branches of anything I worked on for months, because 4-6 weeks after it was approved/merged (and deleted) in to 'develop', I may have to also do a 'hot patch' on to a release branch, and cherry picking is the proscribed way of doing it.

That sounds fairly disorganised and nightmare-ish.

In practise though, does it work well?

I think it possibly did a few years ago. There's a lot of 'tribal knowledge' stuff, and none of these practices were explained when my team (another... 8ish people) were added to the current team months ago.

I think it could be done a lot differently, and better, but any change requires huge amount of political changes. There's probably ... 2 or 3 teams that would need to approve of any process change, and no one wants to be the one to push changes like this ahead. It's "good enough", even though... we often collectively lose a non-trivial amount of time every week or two or three. We log that "wasted time" in a spreadsheet to make a point of it, but... no one is motivated enough the shepherd the required change process. The devops team would have to change a bunch of their scripts, and the process would need to be coordinated among multiple teams of varying sizes and skills. It is kinda disorganized and nightmarish with... I'm trying to count - there's maybe 20+ devs touching this. I suspect this was 'fine' 10 years ago with, say, 5-6 devs who would have dealt with it.

Oh right. My reading of parent was that commits on one dev branch were being cherry-picked for use on another dev branch.

YES! Not everyone has the luxury of evergreen continuous deployments onto their own infra. It is quite common for enterprise software that runs in clients data centers to splinter/branch in this way - since they usually want to manage the risk by staging specific versions of your software for testing before going live. They may consider some of your new features on the main branch as too risky, but still want you to backport fixes to their release branch

I try to avoid horrible things like that at all costs. Sometimes it's easy, sometimes not so much. The rule of thumb is that all branches (unless there is a really, really good reason to do otherwise) are created from the master, and are rebased before the push (by the person, who did the development in this branch), and if there are conflicting changes, before the merge as well.

With the absolutely rarest exceptions all patch releases are done in the same manner as the regular ones, i.e. from the HEAD of master. History must be as linear, as possible.

So there are basically 2 general cases when you really need to share a commit. In the first, you find out in your branch there's something to be fixed, which you know I already fixed in mine, in the commit X. In this case it's better if I reorder commits in my branch so that X is the first one, create a new branch with X, which then is merged in a proper manner. You can rebase then.

Second case is when 2 people with different skill-sets or responsibilities must work on something that "from the above" looks like the same piece of functionality. Then, however hard you may try, it all turns up much messier and they will end up needing to share branches (so they cannot rebase them) with multiple commits. In this case I name one of them responsible for changes made within this task as a whole, so when the work is finished the second (3rd, 4th,...) person doesn't touch the branch(es) in question any more, and the first one might rebase and clean up it as needed.

I have worked places that had really good commit messages.

Git and Subversion even allowing single line “-m” commit messages was a mistake. You would see a lot better messages if they forced you to use the editor. I bet a lot of programmers don’t even know you could do multi line messages and assume there is some short-ish character limit. I know I did for a long time

agreed... I use -m out of laziness a lot, but every time I don't it's much better.

Note that you can provide -m multiple times to add multiple paragraphs to the commit message.

> lot of programmers don’t even know you could do multi line messages

More like most times when people look at logs they will only have the first line visible anyway.

There are probably programmers that do not know there can be more than one line even after looking at a commit with a multi line message

Just a bit, you can have multiple lines with -m, I do it frequently. You can also write single line messages in an editor, which I'm also frequently guilty of. They're orthogonal issues.

Yes, however, -m does encourage people to make single line messages.

I feel a huge pain of resignation when I am forced to use multiple lines to describe a single commit. There is almost no audience for any line of the commit message other than the first line. As far as line length goes, any practical means of displaying the messages, like gitk or git --oneline, is unfriendly to lengthy lines. Gerrit will display all the lines of the tip commit's commit message, so one can amend that commit to create a summary of the others, but then of course the other commits are not as visible.

The character limits are a real thing in git culture. One could start here, with a question posed by an apparent skeptic:

https://stackoverflow.com/questions/2290016/git-commit-messa...

> There is almost no audience for any line of the commit message other than the first line.

git log would definitely show the entire commit message, so I don't see why there would be almost no audience. git blame along with git show or git log -n1 would also allow you to see the rest of the commit message for a particular line in the codebase.

git log would definitely show the entire commit message

git log could show the entire commit message, but I can't remember the last time I saw any developer whose default format wasn't a single-line one. Presumably there are some people who do prefer to see the whole message every time, and maybe that includes you, but IME that's quite rare.

One would actually have to make a change to their global git config to set the pretty setting to display oneline or add a bash alias to run git log --oneline.

By default, it shows the entire message, and, in my experience, most people aren't going to change the default behavior in one specific case.

One would actually have to make a change to their global git config to set the pretty setting to display oneline or add a bash alias to run git log --oneline.

That is true, but I literally can't think of any developer I've worked with in many years who had not done something like that. The typical display in every GUI for git repos that I've come across in recent times is also geared to single-line display, though some of them are marginally better with at least indicating the presence of additional lines than git's own one-line display formats in the CLI.

YMMV, and apparently it does, based on your second paragraph.

As someone who has had to dig deep with git blame, I tremendously value a good long multiline commit message. At the very least it can save the trouble of having to dig up some obscure mailing list discussion or bug report to figure out why a change was made, assuming that exists at all. If it doesn't, all you have is the git commits.

Imagine you followed 50/72 AND the "title" was required to reference "[JIRA-1234]" or "Bugzilla-1234".

Git and Subversion even allowing single line “-m” commit messages was a mistake.

That's a subjective preference. Maybe for some repos it's a good idea to allow or even require longer messages, but certainly not all.

For example, after seeing many different strategies for commit messages over the years, my own preference in many cases is now to permit only one-line commit messages, with a strict character limit, which include a reference to a suitable source such as a feature or bug ID where more details may be found. With git, this can be checked using a pre-commit hook.

The big advantage of this is that a `git log` or similar command with a single-line format can never then hide anything important. Assuming we're talking about an established project that does have things like a bug tracker and some sort of structured project documentation set up, I have found that any time I am tempted to write a longer commit message, there is usually a better place I could record that information, and if not then maybe it wasn't that important anyway.

YMMV, of course. As I said, it's a subjective preference, and no doubt there are many different ways a team might choose to use their tools.

This is a condensed summary of merges, not the commit messages. The actual commit messages for those merges were:

* A few little subsystems and a start of a lot of MM patches. Subsystems affected by this patch series: squashfs, ocfs2, parisc, vfs. With mm subsystems: slab-generic, slub, debug, pagecache, gup, swap, memcg, pagemap, memory-failure, vmalloc, kasan"

* More mm/ work, plenty more to come. Subsystems affected by this patch series: slub, memcg, gup, kasan, pagealloc, hugetlb, vmscan, tools, mempolicy, memblock, hugetlbfs, thp, mmap, kconfig

* More MM work. 100ish more to go. Mike Rapoport's "mm: remove __ARCH_HAS_5LEVEL_HACK" series should fix the current ppc issue. Various other little subsystems"

* Various trees. Mainly those parts of MM whose linux-next dependents are now merged. I'm still sitting on ~160 patches which await merges from -next. Subsystems affected by this patch series: mm/proc, ipc, dynamic-debug, panic, lib, sysctl, mm/gup, mm/pagemap"

* a kernel-wide sweep of show_stack(); pagetable cleanups; abstract out accesses to mmap_sem - prep for mmap_sem scalability work; hch's user acess work. Subsystems affected by this patch series: debug, mm/pagemap, mm/maccess, mm/documentation.

* various hotfixes and minor things; hch's use_mm/unuse_mm clearnups. Subsystems affected by this patch series: mm/hugetlb, scripts, kcov, lib, nilfs, checkpatch, lib, mm/debug, ocfs2, lib, misc.

* A few fixes and stragglers. Subsystems affected by this patch series: mm/memory-failure, ocfs2, lib/lzo, misc

And of course there are hundreds of commit messages for the patches that describe what is really going on. That said, Andrew Morton works in a different way than every other maintainer so the merge commit messages in his case tend to be much less descriptive than everyone else's.

This is why I hate merge commits. I mean, I have no idea of what constitutes this Morton's work and if he could've done better, but I think messages like that are still a problem, they provide zero value and mess up the log. And this is actually only a little worse than what I usually see in merge commits, especially when they are done with some semi-automated tool like GitLab. People rarely do merge by rebase, all useful things that could've been said are usually in the commits themselves (and there are some guidelines about them), so merge commit messages are rarely empty and even more rarely are they useful, because author has no idea what to say. This is just trash.

And even though it never ocured to me to check, yeah, I'd actually expect a higher quality standards of Linux kernel.

Most merge commits in Linux are all but empty and all but useless. Here is one of mine: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/lin....

Commits aren't the valuable output of the development process.

They're valuable when you're looking for who broke the codebase.

You can tell that by the author metadata.

They're valuable for when you're looking for why they broke the code base. This looks like dead code, will I break anything if I remove it? Git blame gets me the ticket number, details on the particular change being made, and (if the author writes their commits well) related files and tests associated with this change. From there, I can see if the other code has since been removed, or if there's an edge case I didn't think of, or if the thing was never plugged in in the first place, or if this is a bug no one has noticed. All within two minutes, and without needing to ask the author (if they're even still available).

Using git blame and looking at a commit that last updated a line allows one to check the message for the reasoning behind adding or updating that line, and the context that line was added or updated.

This could help in terms of preventing regressions by making further updates for example.

At least for me, they definitely are one of the valuable outputs of the development process.

Especially when looking back through older code to see "what did we change since X date?", and/or "what changed between (say) the 3rd and 5th of July?".

That seems to be a fairly standard thing too (from my perspective).

You wouldn't be offended, if you possessed the requisite context for your opinions.

Linux kernel commits are very detailed and high quality. The style can be a bit ad hoc, but the face of enforcement is Linus himself.

What you're looking at here is a throwaway piece of unnecessary text. Git offers the opportunity to include it, but it is generally left blank, because it adds no value. All of the interesting bits are included by incorporation.

In this case, Andrew Morton decided to have a bit of ironic fun with the throwaway text. Dismissals ensue!

I'm not really "offended" since I don't really care about the state of Linux kernel's log. But since you insist on the discussing the case so much, let me add that I'm a person with very low tolerance for humour in the working process. I like jokes in the chat, email, or even in bugtracker's comments for that matter, but the git log (or any change log, for that matter) must be very clean, clear and boring.

So even though I said

> I have no idea of what constitutes this Morton's work and if he could've done better

I very much believe that he could have. For 2 reasons:

1. There are multiple people with huge, broad, non-specific merges in that list, and every single one of them, did, in fact do better than Andrew Morton.

2. I believe that consistency in logs is good, so even in the case somebody really, truly, actually cannot say more, than just "updates" about the changes he introduces (which I don't think is ever true, but let's assume it is), I think "updates|updates|updates|updates" would still be a mile better, than "updates|more updates|yet more updates|still more updates".

> it is generally left blank

Not at all.

> it adds no value

It is used by Linus to check what's going on and see if there's anything he should check more closely (perhaps cross-checking the message with the diffstat); it is used by developers (now or in the future) and journalists to make themselves an idea of what is being merged; it may explain features that are in development and have preparatory work being merged; and so on.

So I'd say there's quite a bit of value there.

Every single one of those pieces of information is included in the original commit messages, which are included by incorporation.

The merge commit message is the equivalent of forwarding an email to someone and adding your comment at the top:

    "Really interesting, read this!"

    "Hey, look what Joe said..."

Or the ever-popular message in CEO-speak:

"?"

Rephrasing the committer's message in the merge commit would be redundant at best, and confusing at worst.

Merge/branch commits can’t be useful by definition. No work was done on the branch/merge. I don’t understand your gripe.

Then why are they wasting space in the log? That's the gripe, the white noise.

Because the second parent commit of the merge commit gives you the pointer to the list of commits off the main branch where the feature is implemented. Without the merge commit, there would be no easy way to group commits that implement a feature.

You're focusing on the wrong part of the picture. Yes, you need that data to be stored somewhere. But the complaint is not that a merge commit or equivalent data structure exists somewhere. It's that if you get the equivalent of 'asdflklf' shown in the log, especially when it's displayed in a compact and supposedly information-dense form, something has gone wrong.

If we take it as true that merge commits have no useful information by definition, shouldn't they have a blank commit message? Or a message of "merged branch X"? And why are we spending lines displaying them in the denser log formats?

All of my merge commits say “merged x with y” and all of my branch commits say “created branch z”

They are useful because it shows very clearly when a branch and merge was done. Dates and times are useful. Knowing the parent of a branch is useful. Knowing when a branch was merged back in to another branch is useful.

> It's that if you get the equivalent of 'asdflklf' shown in the log

I think the fundamental problem is that commands like merge and revert generate their own default commit message and don't bring up the editor so that further updates can be made.

At my job, I always will tell people that they need to include why they're reverting a commit in the commit message. I haven't really done anything about enforcing standards on merge commit messages, but perhaps including the cover letter or PR description in the merge commit would be a good start.

I'm not sure what the fuss is all about. I've only been developing for < 2 years, and I used to add detailed MERGE commit messages, but I realized that it's just duplication of information (which can be read from the INDIVIDUAL commit messages). I've left MERGE commit messages empty since then

This appears to be Linus's rephrasing/summarizing of the commit messages, not actual commit messages anywhere in git history.

> I'm surprised this is allowed in the linux kernel. I am not familiar, but assuming these are commit messages, that's pretty damn pathetic.

Those are mergers, and besides they care more about quality of the commits, than about the quality of commit messages.

It's one of the perks not having some superficial scrum master to satisfy.

My commit logs tend to be full of stuff like "now with less bugs" and "it actually works."

I do too, but I also do not have a sizable fraction of _civilization_ running on top of my code.

I do a ton of that locally (or, sometimes, in a remote branch that I 100% own and no-one else will be touching), but clean it up before pushing or merging.

In academia, nearly all our commit messages are "..."

But once the paper is published no one will ever look at the commits again

Reply on news.ycombinator.com