7 ms·

> The No.1 reason for me is that it makes you use git like it is supposed to be used: Via email and your MUA. Welp, that puts me off using it entirely sadly.

> The No.1 reason for me is that it makes you use git like it is supposed to be used: Via email and your MUA. Welp, that puts me off using it entirely sadly. I hate dealing with mailing lists and refuse to contribute to any project that requires dealing with text patches in 2020. Like it or not, the pull request model is simply easier to deal with and is easier for new users to use.

ddevault 6y ago
The pull request model is not easier to use, you just already know how to use it. Anyone who maintains a large enough GitHub project can attest that there are many people who don't grok GitHub pull requests, either. 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.
- ChickeNES 6y ago
  No, it's not unfamiliarity, I have had to use email to manage and submit patches before, and hated it. This just stinks of doing things the old way in cargo cult like fashion. This whole approach, some development in email, some on the web, and some on a disused IRC channel is exactly why projects like Cairo suffer from lack of contributions. Do people really want to deal with text patches in 2020? I appreciate the back-to-basics approach and aesthetics, but srht just seems to be throwing out the baby with the bathwater.
  - ddevault 6y ago
    >is exactly why projects like Cairo suffer from lack of contributions 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 https://aerc-mail.org. Other good choices include mutt and alpine.
    - Znafon 6y ago
      Do you have a recommendation for a good GUI mail client?
      - ddevault 6y ago
        Claws mail is pretty good IMO. There are some more options here: https://useplaintext.email https://useplaintext.email
        Znafon 6y ago
        Thanks, last time I tested aerc I couldn't find a way to make it download all my mails locally. Is this possible?
        Icyphox 6y ago
        Try mbsync or OfflineIMAP. Both great tools to sync a remote mailbox to local.
        ddevault 6y ago
        No, but you can use it in combination with something like imapsync.
    - hvis 6y ago
      Can you comment on individual lines of a changeset in an email and reply to such comments separately, and then see such conversations in the context of the diff? And then mark them as resolved when that happens? 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/collaborating-with-issues-and-pull-requests/commenting-on-a-pull-request https://docs.github.com/en/free-pro-team@latest/github/colla... As well as the "Resolving conversations" section.
      - ddevault 6y ago
  - aaravchen 6y ago
    For one, many corporate environments no longer directly tie email user identity and code user identity directly together, they frequently manage them thru a third service that both services connect to instead (e.g. OAuth, ActiveDirectory, etc). 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.
- mixedCase 6y ago
  Where do I see all patches neatly organized in threads, ready to be open as a timeline feed? Anything that involves custom filters or scripting an e-mail client is not easier nor more efficient than a web UI made for purpose. 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.
  - ddevault 6y ago
    >Where do I see all patches neatly organized in threads, ready to be open as a timeline feed? Anything that involves custom filters or scripting an e-mail client is not easier nor more efficient than a web UI made for purpose. https://lists.sr.ht/~sircmpwn/sr.ht-dev 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.
    - mixedCase 6y ago
      > https://lists.sr.ht/~sircmpwn/sr.ht-dev https://lists.sr.ht/~sircmpwn/sr.ht-dev 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.
Technically 6y ago
What is "easier" about having to deal with github than your email? Github has needed a non-web-app interface since 2007. It's good to see real competition and not just another clone of github's, erm, interesting design choices.
- Aeolun 6y ago
  Have you dealt with email in the past 10 years? If there is one thing I do not need more of it’s email. I also want nothing in the critical part for development to be email, so I can completely ignore the whole email client.
  - Technically 6y ago
    It would be helpful if you could list the aspects of email that github improves on. I'm sure you're aware you can filter email already, so I don't by this "omg email is so overwhelming" argument from a grown-ass adult.
- SulfurHexaFluri 6y ago
  Github lets me instantly jump in and contribute to a project with an issue report without having to sign up to a mailing list. I hate mailing lists with a passion because they spam my inbox with rubbish. Yes I know you can automate filtering them in to folders but that isn't simple to do when you self host email and use it across multiple computers because most filtering is done client side. I also have one mailing list that seems to have messed up and I'm stuck on the list despite trying to unsubscribe a few times.
  - ddevault 6y ago
    You don't have to sign up for most mailing lists to send an email to them. The default permissions for new lists on SourceHut allow postings from non-subscribers. It's very common to fire off a patch without subscribing.
  - Technically 6y ago
    Email would let me participate without having to sign up with github. Anyway, email has threading, at least. At the very minimum github needs to step up and acknowledge how terrible issues are for communicating.

ddevault 6y ago

The pull request model is not easier to use, you just already know how to use it. Anyone who maintains a large enough GitHub project can attest that there are many people who don't grok GitHub pull requests, either. 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.

ChickeNES 6y ago
No, it's not unfamiliarity, I have had to use email to manage and submit patches before, and hated it. This just stinks of doing things the old way in cargo cult like fashion. This whole approach, some development in email, some on the web, and some on a disused IRC channel is exactly why projects like Cairo suffer from lack of contributions. Do people really want to deal with text patches in 2020? I appreciate the back-to-basics approach and aesthetics, but srht just seems to be throwing out the baby with the bathwater.
- ddevault 6y ago
  >is exactly why projects like Cairo suffer from lack of contributions 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 https://aerc-mail.org. Other good choices include mutt and alpine.
  - Znafon 6y ago
    Do you have a recommendation for a good GUI mail client?
    - ddevault 6y ago
      Claws mail is pretty good IMO. There are some more options here: https://useplaintext.email https://useplaintext.email
      - Znafon 6y ago
        Thanks, last time I tested aerc I couldn't find a way to make it download all my mails locally. Is this possible?
        Icyphox 6y ago
        Try mbsync or OfflineIMAP. Both great tools to sync a remote mailbox to local.
        ddevault 6y ago
        No, but you can use it in combination with something like imapsync.
  - hvis 6y ago
    Can you comment on individual lines of a changeset in an email and reply to such comments separately, and then see such conversations in the context of the diff? And then mark them as resolved when that happens? 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/collaborating-with-issues-and-pull-requests/commenting-on-a-pull-request https://docs.github.com/en/free-pro-team@latest/github/colla... As well as the "Resolving conversations" section.
    - ddevault 6y ago
- aaravchen 6y ago
  For one, many corporate environments no longer directly tie email user identity and code user identity directly together, they frequently manage them thru a third service that both services connect to instead (e.g. OAuth, ActiveDirectory, etc). 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.
mixedCase 6y ago
Where do I see all patches neatly organized in threads, ready to be open as a timeline feed? Anything that involves custom filters or scripting an e-mail client is not easier nor more efficient than a web UI made for purpose. 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.
- ddevault 6y ago
  >Where do I see all patches neatly organized in threads, ready to be open as a timeline feed? Anything that involves custom filters or scripting an e-mail client is not easier nor more efficient than a web UI made for purpose. https://lists.sr.ht/~sircmpwn/sr.ht-dev 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.
  - mixedCase 6y ago
    > https://lists.sr.ht/~sircmpwn/sr.ht-dev https://lists.sr.ht/~sircmpwn/sr.ht-dev 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.

Technically 6y ago

What is "easier" about having to deal with github than your email? Github has needed a non-web-app interface since 2007. It's good to see real competition and not just another clone of github's, erm, interesting design choices.

Aeolun 6y ago
Have you dealt with email in the past 10 years? If there is one thing I do not need more of it’s email. I also want nothing in the critical part for development to be email, so I can completely ignore the whole email client.
- Technically 6y ago
  It would be helpful if you could list the aspects of email that github improves on. I'm sure you're aware you can filter email already, so I don't by this "omg email is so overwhelming" argument from a grown-ass adult.
SulfurHexaFluri 6y ago
Github lets me instantly jump in and contribute to a project with an issue report without having to sign up to a mailing list. I hate mailing lists with a passion because they spam my inbox with rubbish. Yes I know you can automate filtering them in to folders but that isn't simple to do when you self host email and use it across multiple computers because most filtering is done client side. I also have one mailing list that seems to have messed up and I'm stuck on the list despite trying to unsubscribe a few times.
- ddevault 6y ago
  You don't have to sign up for most mailing lists to send an email to them. The default permissions for new lists on SourceHut allow postings from non-subscribers. It's very common to fire off a patch without subscribing.
- Technically 6y ago
  Email would let me participate without having to sign up with github. Anyway, email has threading, at least. At the very minimum github needs to step up and acknowledge how terrible issues are for communicating.