I don't really agree with this. Many projects enjoy a vibrant development community on mailing lists today. Cairo suffers from different issues - and ultimately in Cairo's case it doesn't really matter. Cairo has been "done" for years, it's not the end of the world if it doesn't see much activity.
>Do people really want to deal with text patches in 2020?
Yes. You'll find many of them in this very thread. SourceHut is a brand-new service, only around for 2 years in alpha, and in 2020 alone it transacted 37,000 emails. There's obviously demand here.
One thing that can matter a lot if you're trying out the email workflow is making sure you're using a good client. I made one that I recommend as such: https://aerc-mail.org. Other good choices include mutt and alpine.
Can you read those discussions later in a "flat" presentation without scrolling through emails one-by-one?
These are some of the killer features of the PR/MR Github/Gitlab workflows.
To clarify, I'm talking about steps 4-7 here: https://docs.github.com/en/free-pro-team@latest/github/colla...
As well as the "Resolving conversations" section.
Yes, except for the last bit. Unlike GitHub/GitLab you can also respond to several comments at once.
>Can you read those discussions later in a "flat" presentation without scrolling through emails one-by-one?
I don't know what this means.
Person 1
> Chunk of code 1
Comment
> Chunk of code 2
Comment
Person 2
> Chunk of code 1
Comment
> Chunk of code 2
Comment
Chunk of code 1
Person 1
Comment
Person 2
Comment
Chunk of code 2
Person 1
Comment
Person 2
CommentLooking forward to experiencing it in practice someday. Maybe Emacs will finally migrate off Debbugs.
The issue is brought up repeatedly, but there's no real movement right this moment (or for the last several months, really).
There are several proponents of SourceHut thanks to its email-based workflows and (apparently?) LibreJS compatibility. But none are passionate enough to push for it, thus far, and do the work required.
As opposed to, say, advocates of Gitlab (which got effectively banned by a long list of requirements, alas).
Um, what?
Suppose you have 10 developers sending an average of 10 emails a day. That's 100 * 365, or 36 500 emails a year.
That stat doesn't sound very useful. 10 developers isn't demand.
Cairo's fast antialiasing mode had a memory corruption bug that took 5 years after the bug report to be fixed. https://gitlab.freedesktop.org/cairo/cairo/-/issues/44
There are some more options here:
This also only works well if you have: 1) one commit per change, 2) every reviewer has a fully up to date copy of any/all repos being reviewed, 3) a single change only affects a single repo.
The one-commit-per-change (squashed changes) is not always the preference, but it's effectively mandatory since the presentation format for patches only lends itself well to an isolated patch-diff and not a VCS history of changes (ironic since it's intended for the latter). As a great example of this, it's very difficult to compare the differences between the resulting code between two patches submitted to the same thread when I want to confirm a series of corrections to the original submissions were made properly and without side-effect.
Every reviewer having a fully up-to-date copy of the repo the changes are going into works amazingly well for a fully distributed VCS, defining the gatekeeping maintainer's copy as the ultimate source of truth for the "latest". When multiple maintainers for the repo exist, as in most corporate environments and the monorepo organization, this breaks down. The ultimate source of truth for "latest" is now a remotely hosted repository that no one individual gatekeeps. Therefore all maintainers need to constantly duplicate the remote copy and keep it up to date. Either the maintainer is an active developer that's also creating changes constantly and will therefore need to keep two different copies so they can be building and testing their own development changes while keeping a pristine copy purely for review purposes, or they don't usually do a lot of active development themselves and keeping a local copy at all is purely for the purposes of review. In terms of pushing proliferation of copies of the distributed VCS it works, but when more (but not completely) centralized as most corporate environments/users need it's an extra hurdle that impedes the process rather than helping.
For a single change to affect only a single repo requires at the extreme a monorepo layout, or an extremely well modularized design. As noted before, monorepo is very much against the design (few people should need a fully history copy of the entire repo locally with a monorepo, and many maintainers control the same repo) and defining sufficiently modularized breakdown is nigh impossible with larger projects. The Linux project is a great example of this problem, but has a semi-solution that involves having an even larger developer base involved at different levels of a heirarchy, and split repos for "modules" (independently maintained subcomponents or specialty areas) that have to manually cross-related. This is demonstrably problematic even now when a sub-area uses a separate repo and submits wholesale changes to the downstream project, losing almost all of the history and cross-linked-tracking information in so doing. Recognized as a common problem, the community has either gone the monorepo route where all changes go into the single larger repo at the cost of much greater coordination requirements, or the submodule-like route where each sub-part becomes more isolated but may have cross-cutting changes across multiple separate repos. As the repos proliferate in the latter case, individual maintainers often become responsible for a larger number of repos and the other two problems impact them more.
In summary, the mailing list solved a basic problem for a specific narrow use case at a time when technological constraints and solution options were very different than they are now. While the development/maintenance process can still be made to fit its usage, the large scale needs often no longer match, nor do the same technological restrictions apply. GitHub PRs aren't necessarily significantly better, but they do at least move the same concept to a place where an individual user/maintainer can keep their individual source of truth in one place (online), interact with it without needing a full development system/setup present, AND provides options for moving development processes in a new direction. The last has stagnated pretty badly, but throwing it out for a return to a system that has little to no options for modifying the process to meet modern needs seems overly agressive.
How do I make a minor adjustment to a patch as a response to feedback without resending the whole thing? Anything more complicated than git commit && git push to my remote clone is not easier nor more efficient than the status quo.
These are just two off the top of my head. PRs as a code contribution approach can be improved upon, but mailing lists are not better at all for small projects and are only situationally better for bigger ones.
https://lists.sr.ht/~sircmpwn/sr.ht-dev
>How do I make a minor adjustment to a patch as a response to feedback without resending the whole thing? Anything more complicated than git commit && git push to my remote clone is not easier nor more efficient than the status quo.
git commit && git push also re-sends the entire thing, assuming you rebased, and you should very definitely be rebasing.
That's a multi-purpose mailing list, where I had to read for a couple of minutes to assume belongs to the whole project sr.ht instead of a specific repo (I trusted your response to mean this was an actual 1:1 replacement and that I missed it), and I had to go into one of the patches and find a link to an issue in the tracker, and from there I had to go to the main page of that issue's project, and from there I see there's an ad-hoc association between the tracker and the actual repo by a link in the description which I assume you added because you noticed that it's useful to associate issue trackers and repos. And that's just for finding one of the repos that mailing list covers.
In the end, I still have to come up with custom filters to use to get only the patch requests for the specific repo I'm interested in, and assume everybody follows every single non-obvious instruction to the letter to make it all work.
The whole experience feels like a grabbing a bunch of general purpose tools and trying to get them to work for the project's purpose as well as possible, because there is no solution that solves the problem in obvious ways that doesn't require learning and carefully following a bunch of ceremony without failure. Except in this case, there are such solutions, and I'd have to be a sadist to try to get coworkers to learn and follow every single convention to the letter when they have problems just working well with git in the first place.
> git commit && git push also re-sends the entire thing
Which is not what I wanted, since even half-arsed PR implementations like Bitbucket's (let alone better ones like GitLab's) support dealing with direct feedback and changes that respond to them in a single PR.
> assuming you rebased, and you should very definitely be rebasing.
I do, when working on feature branchs. But that's another nonintuitive thing to get people to unlearn and relearn. Which of course, also includes git send-email.
You can already filter by project, though. Here are all the git.sr.ht patches:
https://lists.sr.ht/~sircmpwn/sr.ht-dev/patches?search=prefi...
The feature is hinted at in the placeholder text on the search box.
>support dealing with direct feedback and changes that respond to them in a single PR.
Linking multiple versions of a patch together into one cohesive patchset is another thing which is possible in theory and prioritized for the alpha.
>I do, when working on feature branchs. But that's another nonintuitive thing to get people to unlearn and relearn. Which of course, also includes git send-email.
Both of which we have detailed tutorials for!
You leave me thinking you actually give a shit about not leaving the average person behind and that ease of use is a priority. So if you can eventually couple the simplicity and performance you already have with slight changes to make the UI at least as obvious as GitHub to both programmers and students, then that's a winner. Just subscribed in hopes to seeing that happen.
If you prefer to use a web-based workflow, then you can both prepare and review patches on our web UI, and they're automatically sent as emails. You don't actually have to interact with email directly at all.
And, once you're used to it, pretty much everyone who uses email can assure you that it's much easier to use, much more efficient, and much more scalable than pull requests.