1. 13

    Ah they tricked me with this one, it’s a Medium article hidden behind another domain.

    (Whenever I see “medium.com” next to lobsters articles I know not to click, since the result will be a weak thinkpiece by a frontend developer, wrapped in obtrusive markup.)

    1.  

      i had literally the exact same response. “Ah, a medium article….about frontend dev……(tab closed)”.

      1. 3

        Interesting ‘hot take’!

        You judge people based on the ‘medium’ that they use.

        1. 8

          “The medium is the message” ;)

          I have to admit though that seeing a medium link is generally a negative signal for me. Still click on many of them.

          1. 7

            I think Medium’s original USP was “only quality content”.

            Predictably, that didn’t scale.

            1.  

              Many confuse Marshall McLuhan’s original meaning of that phrase. It didn’t really mean that the way a message was delivered was part of the message itself. It actually meant that the vast majority of messages were medium or average.

              It would have been better said, “meh, the message is average.”

              1.  

                Interesting interpretation. I am not sure how he originally came to that phrase, but his book certainly spent a lot of time and effort arguing for the now prevalent meaning.

                1.  

                  This didn’t really make sense to me, so I looked it up, and I don’t think that’s right. The original meaning is exactly what we’ve come to understand it as:

                  The medium is the message because it is the medium that shapes and controls the scale and form of human association and action. The content or uses of such media are as diverse as they are ineffectual in shaping the form of human association. Indeed, it is only too typical that the “content” of any medium blinds us to the character of the medium. (Understanding Media: The Extensions of Man, 1964, p.9)

                  I wonder where you’ve heard your interpretation?

                  1.  

                    This comment is obviously a troll. Fitting, given that McLuhan himself was a troll.

            1. 3

              https://begriffs.com lately it’s been database topics, but also includes unix articles, and opinion pieces about the internet (vs the www).

                1. 1

                  Dealers of Lightning is one of my favorite books. How do you like Where Wizards Stay Up Late?

                  1. 2

                    i am still going through it, and will be done in a 2-3 days, will post here then.

                  2. 1

                    I thought wizards was too disjointed. “Inventing the Internet” by Janet Abbate was a more coherent history. Really enjoyed that book.

                    1. 1

                      ah ! thanks for the suggestion, will check that one out as well :)

                  1. 1

                    (Flagged) Posting wikipedia articles doesn’t seem appropriate for lobsters.

                    1. 1

                      My gut instinct as someone that has lurked here for a while but am only new to commenting recently is that one of the worst parts of proggit is people posting plain links to wikipedia articles or software libraries with no context.

                      But I’m glad this was posted because burntsushi’s comment is highly valuable.

                    1. 2

                      Working on it: https://getstream.io/blog/winds-2-0-its-time-to-revive-rss/ It’s not so easy though, it’s a vicious cycle. Less people use RSS, less publishers support RSS, RSS tools degrade in quality and so on.

                      You wouldn’t believe the number of if statements in the Winds codebase just to make RSS work (ish). The standard isn’t really much of a standard with everyone having small variations. Here’s an example, not all feeds implement the guid properly, so you end up with code like this: https://github.com/GetStream/Winds/blob/master/api/src/parsers/feed.js#L82

                      1. 1

                        Now, that looks like an interesting project. I have updated my SaveRSS page to include a link to Winds in the RSS clients section. You might also consider linking to the SaveRSS page for arguments on why to use RSS/Atom as a publisher.

                        Personally, the project isn’t for me, though. I’m a happy user of elfeed, but I can absolutely see how your project can benefit the RSS/Atom community.

                        1. 1

                          Dang, this bloatware is pushing 6k stars on github already. Nothing like an RSS reader that combines Electron, Mongo, Algolia, Redis, machine learning (!), and Sendgrid

                          1. 1

                            l

                            The goal is build an RSS powered experience that people will actually want to use. The tech stack is based around the idea of having a large group of people being able to contribute. (We use Go & RocksDB for most of our tech, so it was a very conscious move to use Node & Mongo for Winds to foster a wider community adoption)

                            1. 1

                              Makes sense. Thanks for the gracious reply, I feel bad about my grumpy comment.

                          1. 4

                            ActivityPub strikes me as the invention of people who believe that the internet = HTTP, and who know about JSON but not RFC822.

                            Some of the example message bodies just look like JSON-ized SMTP headers, “inReplyTo” etc. It looks like it has a MIME-inspired “mediaType” attribute too, but does it allow only one media type per message?

                            Can someone who is more familiar with ActivityPub give me the sales pitch about why existing protocols don’t suffice?

                            1. 6

                              RFC822 is ASCII only to begin with one of the biggest limitations of email related “standards”.

                              Some 6.5 billion people around the globe use non-ascii charecters, and old standards only have layers of hacks upon them to support their usecases to some extent.

                              Why not create new standards from the ground up for the current usecases? I’m not interested in ActivityPub curently, but I have some experience with email and related technologies, and it badly needs a redesign. It won’t happen as none of the parties capable to organise it is interested in it.

                              1. 4

                                My uninformed guess is that with the slow decline of email, there are more & better JSON parsers than there are MIME or email parsers. I would have made the same choice, but my reason would have revolved around JSON’s ability to store structured data, for future flexibility.

                                1. 2

                                  HTTP Headers are the same format like MIME headers, browsers already have everything one would need for mail. Multipart documents (email attachments) are the same format like HTTP file uploads via form. There is a number of headers both share.

                                  1. 1

                                    I think it comes down to tooling. Protocol A could be 10x as widely deployed as protocol B, but if protocol B has better libraries, I’ll give that more weight in my decision of which to use. I had to assemble a multipart MIME message for work a few weeks ago, and everything about the experience was inferior to “create a data structure and convert it to JSON”.

                                    Coders are likely to pick the easiest path, if everything else is roughly equal.

                                2. 1

                                  No reason, really. It’s a marketing effort, mostly.

                                  1. 1

                                    SMTP is forever tainted by spam. ISPs like to block ports, spam filters like to eat mail from new unknown servers, etc.

                                    Giving a pitch for Webmention instead of ActivityPub: Webmention requires the sender to publish an html page that actually links to the target URL. You can be stricter and require a valid microformats2 reply/like/repost/bookmark. That already stops old school pingback spam. For stronger protection, there are clever schemes based on “this non-spam domain you linked to has linked to me”.

                                1. 5

                                  @algernon, thanks for your careful reply to my blog post. You’re right that I overlooked the Github API. I just haven’t yet used tools that hook into it. What are some of your favorite tools?

                                  I think it’s still worth comparing the pros/cons of their proprietary API and the number and maturity of its tools with the ecosystem around email, but I would like to get better educated about the Github tools.

                                  1. 6

                                    I live in Emacs, so https://github.com/vermiculus/magithub, https://github.com/sigma/magit-gh-pulls and https://magit.vc/ itself are my primary tools. They are the most powerful git tools I had the pleasure to work with.

                                    1. 3

                                      I just haven’t yet used tools that hook into it. What are some of your favorite tools?

                                      I can highly recommend githubs own hub: https://github.com/github/hub, https://hub.github.com/hub.1.html

                                    1. 5

                                      Git via email sounds like hell to me. I’ve tried to find some articles that evangelize the practice of doing software development tasks through email, but to no avail. What is the allure of approaches like this? What does it add to just using git by itself?

                                      1. 6

                                        I tried to collect the pros and cons in this article: https://begriffs.com/posts/2018-06-05-mailing-list-vs-github.html

                                        1. 3

                                          I also spoke about this at length in a previous article:

                                          https://drewdevault.com/2018/07/02/Email-driven-git.html

                                          1. 3

                                            While my general experience with git email is bad (it’s annoying to set up, especially in older versions and I don’t like it’s interface too much), my experience of interaction with projects that do this was generally good. You send a patch, you get review, you send a new, self-contained patch, attached to the same thread… etc, in parallel to the rest of the project discussion. It’s a different flavour, but with a project that is used to the flow, it can really be quite pleasing.

                                            1. 2

                                              What does it add to just using git by itself?

                                              I think the selling point is precisely that it doesn’t add anything else. Creating a PR involves more steps and context changes than git-format-patch git-send-mail.

                                              I have little experience using the mailing list flow, but when I had to do so (because the project required it) I found it very easy to use and better for code reviews.

                                              1. 1

                                                Creating a PR involves more steps and context changes than git-format-patch git-send-mail.

                                                I’m not sure I understand. What steps are removed that would otherwise be required?

                                                1. 4

                                                  Simply, it’s “create a fork and push your changes to it”. But also consider that it’s…

                                                  1. Open a web browser
                                                  2. Register for a GitHub account
                                                  3. Confirm your email address
                                                  4. Fork the repository
                                                  5. Push your changes to the fork
                                                  6. Open a pull request

                                                  In this workflow, you switched between your terminal, browser, mail client, browser, terminal, and browser before the pull request was sent.

                                                  With git send-email, it’s literally just git send-email HEAD^ to send the last commit, then you’re prompted for an email address, which you can obtain from git blame or the mailing list mentioned in the README. You can skip the second step next time by doing git config sendemail.to someone@example.org. Bonus: no proprietary software involved in the send-email workflow.

                                                  1. 3

                                                    Also github pull requests involve more git machinery than is necessary. Most people, when they open a PR, choose to make a feature branch in their fork from which to send the PR, rather than sending from master. The PR exposes the sender’s local branching choices unnecessarily. Then, for each PR, github creates more refs on the remote, so you end up having lots stuff laying around (try running git ls-remote | grep pull).

                                                    Compare that with the idea that if you want to send a code change, just mail the project a description (diff) of the change. We all must be slightly brainwashed when that doesn’t seem like the most obvious thing to do.

                                                    In fact the sender wouldn’t even have to use git at all, they could download a recent code tarball (no need to clone the whole project history), make changes and run the diff command… Might not be a great way to do things for ongoing contributions, but works for a quick fix.

                                                    Of course opening the PR is just the start of the future stymied github interactions.

                                                    1. 3

                                                      In my case I tend to also perform steps:

                                                      • 3.1 Clone project
                                                      • 3.2 Use project for a while
                                                      • 3.3 Make some local changes
                                                      • 3.4 Commit those changes to local clone
                                                      • 3.5 Try to open pull request
                                                      • 3.6 Realise GitHub requires me to make a fork of the original repo
                                                      • 4.1 Read man git-remote to see how to point my local clone (with the changes) to my GitHub fork
                                                      • 4.2 Run relevant git remote commands
                                                      • 4.3 Read man git-push to see how to send my changes to the fork rather than the original repo
                                                      1. 2

                                                        To send email, you also have to have an email address. If we are doing a fair comparison, that should be noted as well. Granted, it is much more likely that someone has an email address than a GitHub account, but the wonderful thing about both is that you only have to set them up once. So for this reason, it would be a bit more fair if the list above started from step four.

                                                        Now, if I have GitHub integration in my IDE (which is not an unreasonable thing to assume), then I do not need to leave the IDE at all, and I can fork, push, and open a PR (case in point, Emacs and Magithub can do this). I can also do all of this on GitHub, never leaving my browser. I don’t have to figure out where to send an email, because it automatically sends the PR to the repo I forked from. I don’t even need to open a shell and deal with the commandline. I can do everything with shortcuts and a little bit of mousing around, in both the IDE and the browser case.

                                                        Even as someone who is familiar with the commandline, and is sufficiently savvy with e-mail (at one point I was subscribed to debian-bugs-dist AND LKML, among other things, and had no problem filtering out the few bits I needed), I’d rather work without having to send patches, using Magit + magithub instead. It’s better integrated, hides uninteresting details from me, so I can get done with my work faster. It works out of the box. git send-email does not, it requires a whole lot of set up per repo.

                                                        Furthermore, with e-mail, you have to handle replies, have a firm grip on your inbox. That’s an art on its own. No such issue with GitHub.

                                                        With this in mind, the remaining benefit of git send-email is that it does not involve a proprietary platform. For a whole lot of people, that’s not an interesting property.

                                                        1. 2

                                                          To send email, you also have to have an email address. If we are doing a fair comparison, that should be noted as well.

                                                          I did note this:

                                                          then you’re prompted for an email address, which you can obtain from git blame or the mailing list mentioned in the README

                                                          Magit + magithub […] works out of the box

                                                          Only if you have a GitHub account and authorize it. Which is a similar amount of setup, if not more, compared to setting up git send-email with your SMTP info.

                                                          git send-email does not, it requires a whole lot of set up per repo

                                                          You only have to put your SMTP creds in once. Then all you have to do per-repo is decide where to send the email to. How is this more work than making a GitHub fork? All of this works without installing extra software to boot.

                                                          1. 3

                                                            then you’re prompted for an email address, which you can obtain from git blame or the mailing list mentioned in the README

                                                            With GitHub, I do not need to obtain any email address, or dig it out of a README. It sets things up automatically for me so I can just open a PR, and have everything filled out.

                                                            Only if you have a GitHub account and authorize it. Which is a similar amount of setup, if not more, compared to setting up git send-email with your SMTP info.

                                                            Lets compare:

                                                            e-mail:

                                                            1. Clone repository
                                                            2. Do my business
                                                            3. Figure out where to send e-mail to.
                                                            4. git config so I won’t have to figure it out ever again.
                                                            5. git send-email

                                                            magithub:

                                                            1. clone repo
                                                            2. do my business
                                                            3. fork the repo
                                                            4. push changes
                                                            5. open PR

                                                            The first two steps are pretty much the same, both are easily assisted by my IDE. The difference starts from step 3, because my IDE can’t figure out for me where to send the email. That’s a manual step. I can create a helper that makes it easier for me to do step 4 once I have the address, but that’s about it. For the magithub case, step 3 is SPC g h f; step 4 SPC g s p u RET; step 5 SPC g h p, then edit the cover letter, and , c (or C-c) to finish it up and send it. You can use whatever shortcuts you set up, these are mine. Nothing to figure out manually, all automated. All I have to do is invoke a shortcut, edit the cover letter (the PR’s body), and I’m done.

                                                            I can even automate the clone + fork part, and combine push changes + open PR, so it becomes:

                                                            1. fork & clone repo (or clone if already forked)
                                                            2. do my business
                                                            3. push changes & open PR

                                                            Can’t do such automation with e-mailed patches.

                                                            I’m not counting GitHub account authorization, because that’s about the same complexity as configuring auth for my SMTP, and both have to be done only once. I’m also not counting registering a GitHub account, because that only needs to be done once, and you can use it forever, for any GitHub-hosted repo, and takes about a minute, a miniscule amount compared to doing actual development.

                                                            Again, the main difference is that for the e-mail workflow, I have to figure out the e-mail address, a process that’s longer than forking the repo and pushing my changes, and a process that can’t be automated to the point of requiring a single shortcut.

                                                            Then all you have to do per-repo is decide where to send the email to. How is this more work than making a GitHub fork?

                                                            Creating a GitHub fork is literally one shortcut, or one click in the browser. If you can’t see how that is considerably easier than digging out email addresses from free-form text, then I have nothing more to say.

                                                            And we haven’t talked about receiving comments on the email yet, or accepting patches. Oh boy.

                                                            1. 2

                                                              With GitHub, I do not need to obtain any email address, or dig it out of a README. It sets things up automatically for me so I can just open a PR, and have everything filled out.

                                                              You already had to read the README to figure out how to compile it, and check if there was a style guide, and review guidelines for contribution…

                                                              Lets compare

                                                              Note that your magithub process is the same number of steps but none of them have “so I won’t have to figure it out ever again”, which on the email process actually eliminates two of your steps.

                                                              Your magithub workflow looks much more complicated, and you could use keybindings to plug into send-email as well.

                                                              Can’t do such automation with e-mailed patches

                                                              You can do this and even more!

                                                              1. 2

                                                                You already had to read the README to figure out how to compile it, and check if there was a style guide, and review guidelines for contribution…

                                                                I might have read the README, or skimmed it. But not to figure out how to compile - most languages have a reasonably standardised way of doing things. If a particular project does not follow that, I will most likely just stop caring unless I really, really need to compile it for one reason or another. For style, I hope they have tooling to enforce it, or at least check it, so I don’t have to read long documents and keep it in my head. I have more important things to store there than things that should be automated.

                                                                I would likely read the contributing guidelines, but I won’t memorize it, and I certainly won’t try to remember an e-mail address. I might remember where to find it, but it will still be a manual process. Not a terribly long process, but noticeably longer than not having to do it at all.

                                                                Note that your magithub process is the same number of steps but none of them have “so I won’t have to figure it out ever again”, which on the email process actually eliminates two of your steps.

                                                                Because there’s nothing for me to figure out at all, ever (apart from what repo to clone & fork, but that’s a common step between the two workflows).

                                                                Your magithub workflow looks much more complicated

                                                                How is it more complicated? Clone, work, fork, push, open PR (or clone+fork, work, push+PR), of which all but “work” is heavily assisted. None of it requires me to look anything up, anywhere.

                                                                and you could use keybindings to plug into send-email as well.

                                                                And I do, when I’m dealing with projects that use an e-mail workflow. It’s not about shortcuts, but what can be automated, what the IDE can do instead of requiring me to do it.

                                                                You can do this and even more!

                                                                You can, if you can extract the address to send patches to automatically. You can build something that does that, but then the automation is tied to that platform, just like the PRs are tied to GitHub/GitLab/whatever.

                                                                And again, this is just about sending a patch/opening a PR. There’s so much more PRs provide than that. Some of that, you can do with e-mail. Most of it, you can build on top of e-mail. But once you build something on top of e-mail, you no longer have an e-mail workflow, you have a different platform with which you can interact via e-mail. Think issues, labels for them, reviews (with approvals, rejection, etc - all of which must be discoverable by programs reliably), new commits, rebases and whatnot… yeah, you can build all of this on top of e-mail, and provide a web UI or an API or tools or whatever to present the current state (or any prior state). But then you built a platform which requires special tooling to use to its full potential, and you’re not much better than GitHub. You might build free software, but then there’s GitLab, Gitea, Gogs and a whole lot of others which do many of these things already, and are almost as easy to use as GitHub.

                                                                I’ve worked with patches sent via e-mail quite a bit in the past. One can make it work, but it requires a lot of careful thought and setup to make it convenient. I’ll give a few examples!

                                                                With GitHub and the like, it is reasonably easy to have an overview of open pull requests, without subscribing to a mailing list, or browsing archives. An open PR list is much easier to glance at and have a rough idea than a mailing list. PRs can have labels to help in figuring out what part of the repo they touch, or what state they are in. They can have CI states attached. At a glance, you get a whole lot of information. With a mailing list, you don’t have that. You can build something on top of e-mail that gives you a similar overview, but then you are not using e-mail only, and will need special tooling to process the information further (eg, to limit open PRs to those that need a review, for example).

                                                                With GitHub and the like, you can subscribe to issues and pull requests, and you’ll get notifcations about those and those alone. With a mailing list, you rarely have that option, and must do filtering on your own, and hope that there’s a reasonable convention that allows you to do so reliably.

                                                                There’s a whole lot of other things that these tools provide over plain patches over email. Like I said before, most - if not all - of that can be built on top of e-mail, but to achieve the same level of convenience, you will end up with an API that isn’t e-mail. And then you have Yet Another Platform.

                                                                1. 2

                                                                  How is it more complicated? Clone, work, fork, push, open PR (or clone+fork, work, push+PR)

                                                                  Because the work for the send-email approach is: clone, work, git send-email. This is fewer steps and is therefore less complicated. Not to mention that as projects become more decentralized as they move away from GItHub, the registration process doesn’t go away and starts recurring for every new forge or instance of a forge you work with.

                                                                  But once you build something on top of e-mail, you no longer have an e-mail workflow, you have a different platform with which you can interact via e-mail. Think issues, labels for them, reviews (with approvals, rejection, etc - all of which must be discoverable by programs reliably), new commits, rebases and whatnot…

                                                                  Yes, that’s what I’m advocating for.

                                                                  But then you built a platform which requires special tooling to use to its full potential, and you’re not much better than GitHub

                                                                  No, I’m proposing all of this can be done with a very similar UX on the web and be driven by email underneath.

                                                                  PRs can have labels to help in figuring out what part of the repo they touch, or what state they are in. They can have CI states attached.

                                                                  So let’s add that to mailing list software. I explicitly acknoweldge the shortcomings of mail today and posit that we should invest in these areas rather than rebuilding from scratch without an email-based foundation. But none of the problems you bring up are problems that can’t be solved with email. They’re just problems which haven’t been solved with emails. Problems I am solving with emails. Read my article!

                                                                  but then you are not using e-mail only, and will need special tooling to process the information further (eg, to limit open PRs to those that need a review, for example).

                                                                  So what? Why is this even a little bit of a problem? What the hell?

                                                                  With GitHub and the like, you can subscribe to issues and pull requests, and you’ll get notifcations about those and those alone.

                                                                  You can’t subscribe to issues or pull requests, you have to subscribe to both, plus new releases. Mailing lists are more flexible in this respect. There are often separate thing-announce, thing-discuss (or thing-users), and thing-dev mailing lists which you can subscribe to separately depending on what you want to hear about.

                                                                  Like I said before, most - if not all - of that can be built on top of e-mail, but to achieve the same level of convenience, you will end up with an API that isn’t e-mail.

                                                                  No, you won’t. That’s simply not how this works.

                                                                  Look, we’re just not on the same wavelength here. I’m not going to continue diving into this ditch of meaningless argument. You keep using whatever you’re comfortable with.

                                                                2. 2

                                                                  Your magithub workflow looks much more complicated, and you could use keybindings to plug into send-email as well.

                                                                  I just remembered a good illustration that might explain my stance a bit better. My wife, a garden engineer, was able to contribute to a few projects during Hacktoberfest (three years in a row now), with only a browser and GitHub for Windows at hand. She couldn’t have done it via e-mail, because the only way she can use her email is via her smart phone, or GMail’s web interface. She knows nothing else, and is not interested in learning anything else either, because these perfectly suit her needs. Yet, she was able to discover projects (by looking at what I contributed to, or have starred), search for TODOs or look at existing issues, fork a repo, write some documentation, and submit a PR. She could have done it all from a web browser, but I set up GitHub for Windows for her - in hindsight, I should have let her just use the browser. We’ll do that this year.

                                                                  She doesn’t know how to use the command-line, has no desire, and no need to learn it. Her email handling is… something that makes me want to scream (no filters, no labels, no folders - one big, unorganized inbox), but it suits her, and as such, she has no desire to change it in any way.

                                                                  She doesn’t know Emacs, or any IDE for that matter, and has no real need for them, either.

                                                                  Yet, her contributions were well received, they were useful, and some are still in place today, unchanged. Why? Because GitHub made it easy for newcomers to contribute. They made it so that contributing does not require them to use anything else but GitHub. This is a pretty strong selling point for many people, that using GitHub (and similar solutions) does not affect any other tool or service they use. It’s distinct, and separate.

                                                                  1. 2

                                                                    Not all projects have work for unskilled contributors. Why should we cater to them (who on the whole do <1% of the work) at the expense of the skilled contributors? Particularly the most senior contributors, who in practice do 90% of the work. We don’t build houses with toy hammers so that your grandma can contribute.

                                                                    I’m not saying we shouldn’t make tools which accomodate everyone. I’m saying we should make tools that accomodate skilled engineers and build simpler tools on top of that. Thus, the skilled engineers are not slowed down and the greener contributors can still get work done. Then, there’s a path for newer users to become more exposed to more powerful tools and more smoothly become senior contributors themselves.

                                                                    You need to get this point down if you want me to keep entertaining a discussion with you: you can build the same easy-to-use UX and drive it with email.

                                                                    1. 3

                                                                      I’m not saying we shouldn’t make tools which accomodate everyone. I’m saying we should make tools that accomodate skilled engineers and build simpler tools on top of that.

                                                                      I was under the impression that git + GitHub are exactly these. Git and git send-email for those who prefer those style, GitHub for those who prefer that. The skilled engineers can use the powerful tools they have, while those with a different skillset can use GitHub. All you need is willingness to work with both.

                                                                      you can build the same easy-to-use UX and drive it with email.

                                                                      I’m not questioning you can build something very similar, but as long as e-mail is the only driving power behind it, there will be plenty of people who will turn to some other tool. Because filtering email is something you and I can easily do, but many can’t, or aren’t willing to. Not when there are alternatives that don’t require them to do extra work.

                                                                      Mind you, I consider myself a skilled engineer, and I mainly use GitHub/GitLab APIs, because I don’t have to filter e-mail, nor parse the info in them, the API serves me data I can use in an easier manner. From an integrator point of view, this is golden. If, say, an Emacs integration starts with “Set up your email so mail with these properties are routed here”, that’s not a good user experience. And no, I don’t want to use my MUA to work with git, because magit is a much better, much more powerful tool for that, and I value my productivity.

                                                                      1. 1

                                                                        I’m not questioning you can build something very similar, but as long as e-mail is the only driving power behind it, there will be plenty of people who will turn to some other tool.

                                                                        I’m pretty sure the whole point would be that the “shiny UI” tool would not expose email to the user at all – so the “plenty of people” wouldn’t leave because they wouldn’t know the difference.

                                                                        1. 0

                                                                          So…. pretty much GitHub/GitLab/Gitea 2.0, but with the added ability to open PRs by email (to cater to that workflow), and a much less reliable foundation?

                                                                          Sure. What could possibly go wrong.

                                                          2. 1

                                                            I don’t think you can count signing up for GitHub if you’re not counting signing up for email.

                                                            If you’re using hub, it’s just hub pull-request. No context switching

                                                            1. 2

                                                              If you’re counting signing up for email you have to count that for GitHub, too, since they require an email address to sign up with.

                                                          3. 1

                                                            Using GitHub requires pushing to different repository and then opening the PR on the GitHub Interface, which is a context change. The git-send-mail would be equivalent to sending the PR.

                                                            git-send-email is only one step, akin to opening the PR, no need to push to a remote repository. And from the comfort of your development environment. (Emacs in my case)

                                                      1. 27

                                                        The sr.ht platform linked from the article excites me more than any project in recent memory. It’s a fresh concept, not a Github wannabe like Gitlab.

                                                        sr.ht provides hosted (but open source and self-hostable) mini-services: a git server, continuous integration, a task list, a wiki, and a mailing list. These services are designed to work with each other and with existing distributed tools like git and email. If you want to live on the command line and in mutt you can do that, and if you want to use the sr.ht web interface to do some of those tasks you can do that too. Both ways work together.

                                                        I always thought that if something is going to replace Github it would have to be a paradigm change, and I think that’s what we’re seeing here. Drew’s project blends the wisdom of the kernel hackers with a tasteful web interface.

                                                        1. 11

                                                          Git via mail can be nice but it’s very hard to get used to. It took me ages to set up git send-email correctly, and my problem in the end was that our local router blocked SMTP connections to non-whitelisted servers. This is just one way it can go wrong. I can inagine there are many more.

                                                          And just another minor comment: Everyone knows that Git is decentralized (not federated, btw.), the issue is GitHub, ie the service that adds a certain something to version control, like profiles, stars, commit-stats, fork-counts, followers,etc. A one-sided, technical perspective ignores all of these things as useless and unnecessary – falsely. Centralized platforms have a unfair benefit in this perspective, since there’s only one voice, one claim and no way to question it. One has to assume they make sure that the accounts are all real, and not spam-bots, otherwise nothing makes sense.

                                                          To overcome this issue, is the big task. And Email, which is notoriously bad at any identity validation, might not be the best thing. To be fair, ActivityPub, currently isn’t either, but the though that different services and platforms could interoperate (and some of these might even support a email-interface) seems at the very least interesting to me.

                                                          1. 12

                                                            Article author here. As begriffs said, I propose email as the underlying means of federating web forges, as opposed to ActivityPub. The user experience is very similar and users who don’t know how to or don’t want to use git send-email don’t have to.

                                                            Everyone knows that Git is decentralized (not federated, btw.)

                                                            The point of this article is to show that git is federated. There are built in commands which federate git using email (a federated system) as the transport.

                                                            GitHub, ie the service that adds a certain something to version control, like profiles, stars, commit-stats, fork-counts, followers,etc. A one-sided, technical perspective ignores all of these things as useless and unnecessary – falsely

                                                            Profiles can live on sr.ht, but on any sr.ht instance, or any instance of any other forge software which federates with email. A person would probably still have a single canonical place they live on, and a profile there which lists their forks of software from around the net. Commit stats are easily generated on such a platform as well. Fork counts and followers (stars?) I find much less interesting, they’re just ego stroking and should be discarded if technical constraints require.

                                                            1. 4

                                                              I don’t think that’s a strong argument in favor of git being federated. I don’t think it matters either.

                                                              Git in of itself does not care about the transport. It does not care whether you use HTTP, git:// or email to bring your repo up to date. You can even use an USB stick.

                                                              I’d say git is communication format agnostic, federation is all about standardizing communication. Using email with git is merely another way to pipe git I/O, git itself does not care.

                                                              1. 2

                                                                git send-email literally logs into SMTP and sends a patch with it.

                                                                git am and git format-patch explicitly refer to mailboxes.

                                                                Email is central to the development of Linux and git itself, the two projects git is designed for. Many git features are designed with email in mind.

                                                                1. 4

                                                                  Yes but ultimately both do not require nor care about federation itself.

                                                                  send-email is IMO more of a utility function, git am or format-patch, which as you mention go to mailboxes, have nothing to do with email’s federated nature. Neither is SMTP tbh, atleast on the Client-Server side.

                                                                  They’re convenience scripts that do the hard part of writing patches in mails for you, you can also just have your mailbox on a usb stick and transport it that way. And the SMTP doesn’t need to go elsewhere either.

                                                                  I guess the best comparison is that this script is no more than a frontend for Mastodon. The Frontend of Mastodon isn’t federated either, Mastodon itself is. Federation is the server-to-server part. That’s the part we care about. But git doesn’t care about that.

                                                                  1. 9

                                                                    I see what you’re getting at. I have to concede that you are correct in a pedantic sense, but in a practical sense none of what you’re getting at matters. In a practical sense, git is federated via email.

                                                                  2. 3

                                                                    That various email utilities are included seems more like a consequence of email being the preferred workflow of git developers. I don’t see how that makes it the canonical workflow compared to pulling from remotes via http or ssh, git has native support for both after all.

                                                                2. 1

                                                                  I belive that @tscs37 already showed that Git is distributed, since all nodes are equal (no distinction between clinets and servers), while a git networks can be structured in a federated fashion, ir even in a centralized one. What the transport medium has to do with this is still unclear in my view.

                                                                  Fork counts and followers (stars?) I find much less interesting, they’re just ego stroking and should be discarded if technical constraints require

                                                                  That’s exactly my point. GitHub offers a unit-standard, and easily recognisable and readable (simply because everyone is used to it). This has a value and ultimately a relevance, that can’t just be ignored, even if this reason is nonsense. It would just be another example of technical naïve.

                                                                  I’ve shown my sympathy for ideas like these before, ad I most certainly don’t want to make the impression of a GitHub apologist. All I want to remind people is that the Social aspect beyond necessity (builds, issue trackers, …) are all things one has to seriously consider and tackle when one is interested in offering an alternative to GitHub, with any serious ambitions.

                                                                  1. 1

                                                                    I don’t think sr.ht has to please everyone. People who want these meaningless social features will probably be happier on some other platform, while the veterans are getting work done.

                                                                    1. 1

                                                                      I’m fine with people using mailing-list oriented solutions (the elitism might be a bit off-putting, but never mind). I just don’t think that it’s that much better than the GitPub idea.

                                                                      People who want these meaningless social features will probably be happier on some other platform, while the veterans are getting work done.

                                                                      If having these so-called “meaningless social features” helps a project thrive, attract contributers and new users, I wouldn’t conciser these meaningless. But if that’s not what you are interested in, that’s just ok.

                                                                3. 2

                                                                  our local router blocked SMTP connections to non-whitelisted servers

                                                                  The article says that sr.ht can optionally send the emails for you, no git send-mail required: “They’ll enter an email address (or addresses) to send the patch(es) to, and we’ll send it along on their behalf.”

                                                                  Also what mail transfer agent were you pointing git send-mail at? You can have it send through gmail/fastmail/etc servers – would your router block that?

                                                                  GitHub […] adds a certain something to version control, like profiles, stars, commit-stats, fork-counts, followers

                                                                  How about mirroring code on github to collect stars? Make it a read-only mirror by disabling issues and activating the pull request rejection bot. Git, Linux, and Postgres do this, and probably other projects do too.

                                                                  Email […] is notoriously bad at any identity validation

                                                                  Do SPF, DKIM and DMARC make this no longer true, or are there still ways to impersonate people?

                                                                  1. 1

                                                                    Also what mail transfer agent were you pointing git send-mail at?

                                                                    Fastmail. Was too esoteric for the default settings of my router. And if it weren’t for support, I would have never guessed that that was the issue, since the whole interface is so alien to most people (just like the questions: did I send the right commits, is my message formatted correctly, etc.)

                                                                    How about mirroring code on github to collect stars? Make it a read-only mirror by disabling issues and activating the pull request rejection bot. Git, Linux, and Postgres do this, and probably other projects do too.

                                                                    I’m not saying it’s perfect (again, I’m no GitHub apologist) – my point is that it isn’t irrelevant!

                                                                    Do SPF, DKIM and DMARC make this no longer true, or are there still ways to impersonate people?

                                                                    Yes, if someone doesn’t use these things. And claiming “oh, but they just should” is again raising the entry barrier, which is just too high the way it already would be.

                                                                    1. 1

                                                                      Yes, if someone doesn’t use these things. And claiming “oh, but they just should” is again raising the entry barrier, which is just too high the way it already would be.

                                                                      This doesn’t damn the whole idea, it just shows us where open areas of development are.

                                                                1. 3

                                                                  One nit: GPG 2.1+, I think, actually does start gpg-agent automatically on demand. But the main reason it does that is because for some unknown reason the GPG people decided to move most of the system’s functionality out of the gpg binary and into like 5 daemons that you now have to have running all the time and muddy the whole thing up. Why the old system was inadequate other than the fact that it was old and not shiny and overengineered is beyond me. (If someone knows, I would love to find out.)

                                                                  That all being said I am very happy to see this experiment. PGP is awful. I’d love to see it finally die.

                                                                  1. 10

                                                                    GPG contains lots of engineering effort to make sure that keys are not accidentally leaked to swap, and that applications using gpg under the hood have a safe method of doing so.

                                                                    I haven’t seen the GPG threat model fully documented but it’s definitely much more involved than Enchive’s.

                                                                    1. 5

                                                                      They split the program into communicating parts to help isolate the address spaces of the executables.

                                                                      See the section of Neal’s talk starting at 0:31:45 - https://begriffs.com/posts/2016-11-05-advanced-intro-gnupg.html

                                                                      1. 1

                                                                        I finally made time to look at this, thanks! AFAICT there are two reasons he gave (I watched until about 40 minutes left in the video; the dumb player UI won’t show me how far in that is):

                                                                        1. Each component has a separate address space
                                                                        2. Future window managers with “trusted windows” could treat pinentry specially, “somehow”, because it’s forked from gpg-agent

                                                                        Honestly I don’t see why either of those things couldn’t just be accomplished with the exact same architecture except using regular subprocesses instead of daemons. Can anyone give a reason that isn’t the case?

                                                                        Reason 2 in particular seems like a lot of engineering to support a vaguely defined future scenario which may or may not show up, ever, and certainly does not exist now.

                                                                      2. 2

                                                                        They broke a whole bunch things when they moved to that new architecture and much if it was never fixed. It’s one of the reasons I stopped using GnuPG directly.

                                                                      1. 7

                                                                        This is a great usability improvement. Thank you Peter Hessler :)

                                                                        That said, it’s still a little bit sad that this is only just being introduced in 2018.

                                                                        1. 33

                                                                          That said, it’s still a little bit sad that this is only just being introduced in 2018.

                                                                          Technically - OpenBSD has had various toolings (1, 2, 3 and others) to do this very task for quite a long time. But none of them were considered the correct approach.

                                                                          Also, this is something that’s pretty unique to OpenBSD IMO. The end result is the same as with other systems.. sure. But this is unique among the unix world.

                                                                          Q: What’s the difference?

                                                                          Glad I asked! This is entirely contained within the base system and requires no tools beyond ifconfig!

                                                                          Linux has ip, iw, networkmanager, iwconfig..(likely others)… and they are all using some weird combo of wpa_supplicant.. autogen’d text files.. and likely other things.

                                                                          Have you ever tried to manually configure wireless on linux? It’s a nightmare. Always has been.

                                                                          NetworkManager does a really good job of making it feel like there isn’t a kludge going on behind the scenes.. It does this by gluing all the various tools together so you don’t have to know about them. IMO this is what happens when you “get it done now” vs “do it right”.

                                                                          With great simplicity comes great security:

                                                                          NetworkManager@6c3174f6e0cdb3e0c61ab07eb244c1a6e033ff6e:

                                                                          github.com/AlDanial/cloc v 1.74  T=28.62 s (48.2 files/s, 45506.1 lines/s)
                                                                          --------------------------------------------------------------------------------
                                                                          Language                      files          blank        comment           code
                                                                          --------------------------------------------------------------------------------
                                                                          PO File                          66         125328         161976         457879
                                                                          C                               541          71112          66531         321839
                                                                          C/C++ Header                    528          10430          15928          34422
                                                                          XML                              59           1406           2307           6692
                                                                          make                              6            885            229           5009
                                                                          Python                           40           1189           1128           4597
                                                                          NAnt script                      65            626              0           3968
                                                                          m4                                8            237            123           1958
                                                                          Lua                              11            212            453           1314
                                                                          Bourne Shell                     21            232            238           1115
                                                                          XSLT                              5             65              3            929
                                                                          Perl                              4            166            243            480
                                                                          Bourne Again Shell               11             30             35            241
                                                                          C++                               4             62            121            178
                                                                          YAML                              4             12              6            161
                                                                          JavaScript                        1             33             21            130
                                                                          Ruby                              3             39             92            110
                                                                          Lisp                              2             15             24             23
                                                                          --------------------------------------------------------------------------------
                                                                          SUM:                           1379         212079         249458         841045
                                                                          --------------------------------------------------------------------------------
                                                                          

                                                                          VS

                                                                          ifconfig@1.368:

                                                                          github.com/AlDanial/cloc v 1.74  T=0.12 s (32.2 files/s, 58201.7 lines/s)
                                                                          -------------------------------------------------------------------------------
                                                                          Language                     files          blank        comment           code
                                                                          -------------------------------------------------------------------------------
                                                                          C                                2           1009            345           5784
                                                                          C/C++ Header                     1              7             16             58
                                                                          make                             1              3              1              6
                                                                          -------------------------------------------------------------------------------
                                                                          SUM:                             4           1019            362           5848
                                                                          -------------------------------------------------------------------------------
                                                                          

                                                                          Anyway - I guess my point is this:

                                                                          • Almost every OS achieves this goal.. sure.
                                                                          • Most have had this feature for quite some time.. agree (Including OpenBSD!).
                                                                          • None of them have it implemented as simply and well-thought-out as OpenBSD.
                                                                          1. 5

                                                                            Have you ever tried to manually configure wireless on linux? It’s a nightmare. Always has been.

                                                                            No. The Linux’s I use come with an out-of-the-box experience that makes wireless as easy as clicking a box, clicking a name, typing in the password, it works, and it reconnects when nearby. They have been like that since I bought an Ubuntu-specific Dell a long time ago. They knew it was a critical feature that needed to work easily with no effort with some doing that upon installation so parts of the install could be downloaded over WiFi. Then, they did whatever they had to do in their constraints (time/talent/available code) to get it done.

                                                                            And then I was able to use it with only breaks being wireless driver issues that had answers on Q&A sites. Although that was annoying, I didn’t have to think about something critical I shouldn’t have to think about. Great product development in action for an audience that has other things to do than screw around with half-built wireless services. That’s a complement about what I used rather than a jab at OpenBSD’s which I didn’t use. I’m merely saying quite a few of us appreciate stuff that saves us time once or many times. If common and critical, adoption can go up if it’s a solved problem with minimal intervention out of the box.

                                                                            That said, props to your project member who solved the problem with a minimally-complex solution in terms of code and dependencies. I’m sure that was hard work. I also appreciate you illustrating that for us with your comparisons. The difference is almost comical in the work people put in with very different talents, goals and constraints. And m4 isn’t gone yet. (sighs)

                                                                            1. 7

                                                                              No. The Linux’s I use come with an out-of-the-box experience that makes wireless as easy as clicking a box, clicking a name, typing in the password, it works, and it reconnects when nearby.

                                                                              And then something goes wrong in the fragile mess of misfeatures, and someone has to dig in and debug, or a new feature comes along and someone has to understand the stack of hacks to understand it, before it can be added. There’s something to be said for a system that can be understood.

                                                                              1. 4

                                                                                There is something to be said for a system to be understood. I totally agree. I also think there’s something to be said for a reliable, more-secure system that can be effortlessly used by hundreds of millions of people. A slice of them will probably do things that were worth the effort. The utilitarian in me says make it easy for them to get connected. The pragmatist also says highly-usable, effortless experience leads to more benefits in terms of contributions, donations, and/or business models. These seemingly-contradicting philosophies overlap in this case. I think end justifies the means here. One can always refactor the cruddy code later if it’s just one component in the system with a decent API.

                                                                                1. 3

                                                                                  One can always refactor the cruddy code later if it’s just one component in the system with a decent API.

                                                                                  The problem isn’t the code, it’s the system that it’s participating in.

                                                                                  1. 2

                                                                                    One can always refactor the cruddy code later if it’s just one component in the system with a decent API.

                                                                                    This just leads to systemd, and more misfeatures…

                                                                                    1. 3

                                                                                      There’s Linux’s without systemd. Even those that had it didn’t before they got massive adoption/impact/money. So, it doesn’t naturally lead to it. Just bad, decision-making in groups controlling popular OS’s from what I can tell. Then, there’s also all the good stuff that comes with their philosophy that strict OS’s like OpenBSD haven’t achieved. The Linux server market, cloud, desktops, embedded, and Android are worth the drawbacks if assessing by benefits gained by many parties.

                                                                                      Personally, I’m fine with multiple types of OS being around. I like and promote both. As usual, I’m just gonna call out anyone saying nobody can critique an option or someone else saying it’s inherently better than all alternatives. Those positions are BS. Things things are highly contextual.

                                                                              2. 1

                                                                                This is really great. I wish all other projects can do that, preferring elegancy to throwing code on the wall, but sometimes life really takes its toll and we cave and just make Frankenstein to get shit done.

                                                                                I really appreciate all the works by OpenBSD folks. Do you have any idea how other *BSD’s deal with the wireless?

                                                                                1. 1

                                                                                  Do you have any idea how other *BSD’s deal with the wireless?

                                                                                  I don’t - sorry :D

                                                                              3. 3

                                                                                Whats really sad is that the security of other operating systems can’t keep up despite having more man power.

                                                                                1. 2

                                                                                  It’s almost like if you prioritize the stuff that truly matters, and be willing to accept a little bit of UX inconvenience, you might happen upon a formula that produces reliable software? Who would have thought?

                                                                                  1. 2

                                                                                    That’s what I told OpenBSD people. They kept on a poorly-marketed monolith in unsafe language without the methods from CompSci that were knocking out whole classes of errors. They kept having preventable bugs and adoption blockers. Apparently, the other OS developers have similarly, hard-to-change habits and preferences with less focus on predictable, well-documented, robust behavior.

                                                                                  2. 1

                                                                                    I think this is just a matter of what you think matters. There’s no sadness here. The ability to trade off security for features and vice versa is good. It lets us accept the level of risk we like.

                                                                                    On the other hand, it’s really sad, for instance, that OpenBSD has had so many public security flaws compared to my kernel ;P

                                                                                    1. 1

                                                                                      On the other hand, it’s really sad, for instance, that OpenBSD has had so many public security flaws compared to my kernel ;P

                                                                                      What’s your kernel?

                                                                                      1. 2

                                                                                        It’s a joke. Mine is a null kernel. It has zero code, so no features, so no security flaws. Just like OpenBSD has fewer features and fewer known security flaws than Linux, mine has fewer features but no security flaws.

                                                                                        Unlike OpenBSD, mine is actually immune to Meltdown and Spectre.

                                                                                        1. 1

                                                                                          Not having public flaws doesn’t mean you don’t have flaws. Could mean not enough people are even considering checking for flaws. ;)

                                                                                          1. 1

                                                                                            Oh OK lol.

                                                                                    2. 0

                                                                                      That said, it’s still a little bit sad that this is only just being introduced in 2018.

                                                                                      Would you like to clarify what you mean by this comment? Cause right now my interpretation of it is that you feel entitled to have complicated features supported in operating systems developed by (largely unpaid) volunteers.

                                                                                      1. 11

                                                                                        I’m getting a bit tired of every complaint and remark being reduced to entitlement. Yes, I know that there is a lot of unjustified entitlement in the world, and it is rampant in the open source world, but I don’t feel entitled to anything in free or open source software space. As someone trying to write software in my spare time, I understand how hard it is to find spare time for any non-trivial task when it’s not your job.

                                                                                        Though I am not a heavy user, I think OpenBSD is an impressive piece of software, with a lot of thought and effort put into the design and robustness of the implementation.

                                                                                        I just think it’s somewhat disheartening that something this common (switching wireless networks) was not possible without manual action (rewriting a configuration file, or swapping configuration files, and restarting the network interface) every time you needed to switch or moved from home to the office.

                                                                                        Whether you feel like this is me lamenting the fact that there are so few contributors to important open source projects, me lamenting the fact that it is so hard to make time to work on said project, or me being an entitled prick asking for features on software I don’t pay for (in money or in time/effort) is entirely your business.

                                                                                        1. 5

                                                                                          Just for the record I didn’t think you sounded entitled. The rest of the comment thread got weirdly sanctimonious for some reason.

                                                                                          Volunteers can work on whatever they want, and anybody’s free to comment on their work. Other operating systems have had the ability to switch wifi networks now for a long time, so it’s fair to call that out. And then Peter went and did something about it which is great.

                                                                                          Previously I’ve been using http://ports.su/net/wireless for wifi switching on my obsd laptop, but will use the new built-in feature when I upgrade the machine.

                                                                                          Some of the delay for the feature may be because the OS, while very capable, doesn’t seem designed to preemptively do things on the user’s behalf. Rather the idea seems to be that the user knows what’s best and will ask the OS to do things. For instance when I dock or undock my machine from an external monitor it won’t automatically switch to using the display. I have a set of dock/undock scripts for that. I appreciate the simple “manual transmission” design of the whole thing. The new wifi feature seems to be in a similar spirit, where you rank each network’s desirability and the OS tries in that order.

                                                                                          1. 2

                                                                                            Interesting, I didn’t know about that to. I used my own bash script to juggle config files and restart the interface, but the new support in ifconfig itself is much easier.

                                                                                            I think the desire for OpenBSD to not do things without explicit user intent are certainly part of why this wasn’t added before, as well as limited use as a laptop OS until relatively recently.

                                                                                          2. 2

                                                                                            Thanks for taking the time to respond.

                                                                                            To be clear, I don’t believe you’re some sort of entitled prick – I don’t even know you. But, I do care that people aren’t berating developers with: “That’s great, but ____” comments. Let’s support each other, instead of feigning gratitude. It wasn’t clear if that’s what you were doing, hence, my request for clarification.

                                                                                            That being said, my comment was poorly worded, and implied a belief that you were on the wrong side of that. That was unfair, and I apologize.

                                                                                            I just think it’s somewhat disheartening that something this common (switching wireless networks) was not possible without manual action (rewriting a configuration file, or swapping configuration files, and restarting the network interface) every time you needed to switch or moved from home to the office.

                                                                                            Well, I’m just not going to touch this…. :eyeroll:

                                                                                            1. 1

                                                                                              I apologize if my response was a little bit snide. I’ve been reading a lot of online commentary that chunks pretty much everything into whatever people perceive as wrong with society (most commonly: racism, sexism, or millenial entitlement - I know these are real and important issues, but not everything needs to be about them). I read your remark in the context and may have been a little harsh.

                                                                                              Regarding the last segment - how WiFi switching worked before - there may have been better ways to do this, but I’m not sure they were part of the default install. When I needed this functionality on OpenBSD, I basically wrote a bash script to do these steps for me on demand, and that worked alright for me. It may not have been the best way, so my view of the OpenBSD WiFi laptop landscape prior to the work of Peter may not be entirely appropriate or accurate.

                                                                                            2. 1

                                                                                              I just think it’s somewhat disheartening that something this common (switching wireless networks) was not possible without manual action (rewriting a configuration file, or swapping configuration files, and restarting the network interface) every time you needed to switch or moved from home to the office.

                                                                                              I’m more blunt here that leaving that to be true in a world with ubiquitous WiFi was a bad idea if they wanted more adoption and donations from market segment that wanted good, out-of-the-box support for WiFi. If they didn’t want that, then it might have been a good choice to ignore it for so long to focus on other things. It all depends on what their goals were. Since we don’t know them, I’ll at least say that it was bad, neutral, or good depending on certain conditions like with anything else. The core userbase was probably OK with whatever they had, though.

                                                                                            3. 3

                                                                                              First, both free speech and hacker culture say that person can gripe about what they want. They’re sharing ideas online that someone might agree with or act on. We have a diverse audience, too.

                                                                                              Second, the project itself has developers that write cocky stuff about their system, mock the other systems, talk that one time about how they expect more people to be paying them with donations, more recently talk about doing things like a hypervisor for adoption, and so on. Any group doing any of that deserves no exception to criticism or mockery by users or potential users. It’s why I slammed them hard in critiques, only toning it down for the nice ones I met. People liking critiques of other projects or wanting adoption/donations should definitely see others’ critiques of their projects, esp if its adoption/donation blockers. I mean, Mac’s had a seemless experience called Rendevous or something in 2002. If I’m reading the thread right, that was 16 years before OpenBSD something similar they wanted to make official. That OpenBSD members are always bragging when they’re ahead of other OS’s on something is why I’m mentioning it. Equal treatment isn’t always nice.

                                                                                              “But, I do care that people aren’t berating developers with: “That’s great, but ____” comments. Let’s support each other, instead of feigning gratitude. It wasn’t clear if that’s what you were doing, hence, my request for clarification.”

                                                                                              I did want to point out that we’ve had a lots of OpenBSD-related submissions and comments with snarky remarks about what other developers or projects were doing. I at least don’t recall you trying to shut them down with counterpoints assessing their civility or positivity toward other projects (say NetBSD or Linux). Seems a little inconsistent. My memory is broken, though. So, are you going to be countering every negative remark OpenBSD developers or supporters make about projects with different goals telling them to be positive and supportive only? A general rule of yours? Or are you giving them a pass for some reason but applying the rule to critics of OpenBSD choices?

                                                                                              1. 1

                                                                                                I at least don’t recall you trying to shut them down with counterpoints assessing their civility or positivity toward other projects (say NetBSD or Linux). Seems a little inconsistent.

                                                                                                I’m not the Internet Comment Police, but you seem to think you are for some reason… Consider this particular instance “me griping about what I want.”

                                                                                                Or are you giving them a pass for some reason but applying the rule to critics of OpenBSD choices?

                                                                                                This wasn’t about OpenBSD at all. This started out as a request for clarification on the intent of an ambiguous comment that seemed entitled. There seems to be a lot of that happening today, and a lot of people defending it for whatever reason, which is even worse.

                                                                                                1. 1

                                                                                                  I’m not the Internet Comment Police

                                                                                                  Your comments came off that way to me between the original and follow-ups. Far as not about OpenBSD, it’s in a thread on it with someone griping it lacked something they wanted. The OpenBSD members griping about third party projects not having something they wanted to see more of typically got no comment from you. The inconsistency remains. I’m writing it off as you’re just a fan of their style of thinking on code, quality, or something.

                                                                                              2. 2

                                                                                                i think he’s sad that there haven’t been enough volunteers to make it happen sooner

                                                                                                1. 2

                                                                                                  That’s certainly one possibility, but not how I took it initially, and why I asked for clarification. I’ve seen too many people over the years attempt to disguise their entitlement by saying “thanks.”

                                                                                                  I’d have liked to see this comment worded as:

                                                                                                  This is a great usability improvement. Thank you Peter Hessler :) It’s a shame that there isn’t a better way to bring these important usability features to OpenBSD faster. What is the best way to help make that happen? Donations to the OpenBSD Foundation? Sponsor the work directly? Something else?

                                                                                                  Now, it’s also possible that the OP has ties to OpenBSD, and the comment was self-deprecating. But, one can’t infer that from the information we see without investigating who the OP is, and their affiliations…

                                                                                                  1. 0

                                                                                                    one can’t infer anything beyond what they said

                                                                                                    1. 2

                                                                                                      I’m not sure you understand what infer means. One certainly can infer meaning from a comment, based on previous actions, comments, etc..

                                                                                                      My point remains: It’d be nice if the OP would clarify what they mean. My interpretation of the OP’s comment is just as likely as your interpretation. My interpretation is damaging to the morale of existing volunteer contributors to FOSS, and gives potential contributors to FOSS reasons to not contribute all together. I don’t know about you, but I want to encourage people to contribute to FOSS, as doing so moves us closer to a free and open society. And, that alone, is the reason I’m even bothering to continue responding to this thread…

                                                                                                      1. 1

                                                                                                        he said “it’s sad.” that’s all we know. the leap is that this means “entitlement.”

                                                                                                        1. 1

                                                                                                          “It’s pretty sad that it took someone else so long to prioritize work I think is necessary.”

                                                                                                          I think it’s pretty easy to take what was written and read it this way. But maybe my glass is half empty today.

                                                                                                        2. 0

                                                                                                          One can infer based on a comment, but the inference will most likely be dimwitted bullshit.

                                                                                                          Without the magic trifecta of body language, vocal intonation, and facial expression us monkeys are just shit at picking up on any extra meaning. So take the comment at face value.

                                                                                                          It expresses gratitude, it focuses on a specific recipient, and it lauds the feature. After, it regrets that it couldn’t/didn’t happen earlier.

                                                                                                          There’s no hidden meaning here, and if the commenter intended a hidden meaning he’s a dufus too, because there’s no unicode character for those. U+F089A6CDCE ZERO WIDTH SARCASTIC FUCK YOU MARK notwithstanding.

                                                                                                          At some point we all need to stop insisting that we have near-telepathic powers, especially outside of meatspace.

                                                                                                          1. 2

                                                                                                            So, what you’re saying is that I can write anything I want, and since you can’t see or hear other clues, there’s no way you can downvote (in good faith) this comment as trolling?

                                                                                                            Not sure text works that way…

                                                                                                    2. 1

                                                                                                      They had the solution to do it all the time, but it wasn’t invented here, so it’s bad.

                                                                                                1. 8

                                                                                                  Given that most popular email clients these days are awful and can’t handle basic tasks like “sending email” properly

                                                                                                  I agree with the sentiment in general, but once you’re in the position where everybody else does it wrong and you’re the last person on the planet that does it right, then maybe it’s time to acknowledge that the times have changed and that the old way has been replaced by the new way and that maybe it is you who is wrong and not everybody else.

                                                                                                  And I’m saying this as a huge fan of plain-text only email, message threading and inline quotes using nested > to define the quote level.

                                                                                                  It’s just that I acknowledge that I have become a fossil as the times have changed.

                                                                                                  1. 3

                                                                                                    once you’re in the position where everybody else does it wrong and you’re the last person on the planet that does it right

                                                                                                    Thankfully we haven’t reached this position for email usage on technical projects. Operating systems, browsers, and databases still use developer mailing lists, and system programmers know how to format emails properly for the benefit of precise line-oriented tools.

                                                                                                    I acknowledge that I have become a fossil as the times have changed

                                                                                                    If the technology and processes you prefer have intrinsic merit, then why regretfully and silently abandon them? I’m not saying we should refuse to cooperate on interesting new projects simply because they use slightly worse development processes. But we should let people know about the existence of other tools and ways to collaborate, and explain the pros and cons.

                                                                                                    1. 2

                                                                                                      If the technology and processes you prefer have intrinsic merit, then why regretfully and silently abandon them?

                                                                                                      Because when I didn’t, people were complaining about my quoting style, not understanding which part of the message was mine and which wasn’t and complaining that me stripping off all the useless bottom quote caused them to lose context.

                                                                                                      This was a fight it didn’t feel worth fighting.

                                                                                                      I can still use my old usenet quoting habits when talking to other old people on mailing lists (which is another technology on the way out it seems), but I wouldn’t say that the other platforms and quoting styles the majority of internet users use these days are wrong.

                                                                                                      After all, if the maiority uses them, it might as well be the thing that finally helped the “other” people to get online to do their work, so it might very well be time for our “antiquated” ways to die off.

                                                                                                    2. 1

                                                                                                      I’d like to try to convince you that it’s _good* that plain text email is no longer the norm.

                                                                                                      First, let’s dispense with a false dichotomy: I’m not a fan of HTML emails that are heavy on layout tables and (especially) images with no text equivalents. Given my passion for accessibility (see my profile), that should come as no surprise.

                                                                                                      But HTML emails are good for one thing: providing hyperlinks without exposing URLs to people. As much as good web developers aim for elegant URLs, the fact remains that URLs are for machines, not people. A hyperlink with descriptive text, where the URL is available if and only if the reader really wants it, is more humane.

                                                                                                      For longer emails, HTML is also good for conveying the structure of the text, e.g. headingsg and lists.

                                                                                                      Granted, Markdown could accomplish the same things. But HTML email actually took off. Of course, you could hack together a system that would let you compose an email in Markdown and send it in both plain text and HTML. For folks like us that don’t prefer WYSIWYG editors, that might be the best of all worlds.

                                                                                                      1. 2

                                                                                                        But HTML emails are good for one thing: providing hyperlinks without exposing URLs to people.

                                                                                                        That doesn’t come without a huge cost. People don’t realize that they need to know the underlying URL and don’t care to pay attention to it. That leads to people going places they didn’t expect or getting phished and the like.

                                                                                                        Those same people probably wouldn’t notice the difference between login.youremail.com and login.yourema.il.com either, though. So I’m not saying the URL is the solution but at least, putting it in front of you, gives you a chance.

                                                                                                        1. 2

                                                                                                          As much as good web developers aim for elegant URLs, the fact remains that URLs are for machines, not people.

                                                                                                          I’m not sure about this… at least the whole point of DNS is to allow humans to understand URLs. Unreadable URLs seem to be a relatively recent development in the war against users.

                                                                                                          1. 2

                                                                                                            Not only do I completely agree with you but you are also absolutely right about that.

                                                                                                            Excerpt from section 4.5 of the RFC3986 - Uniform Resource Identifier (URI): Generic Syntax:

                                                                                                            Such references are primarily intended for human interpretation
                                                                                                            rather than for machines, with the assumption that context-based
                                                                                                            heuristics are sufficient to complete the URI [...]
                                                                                                            

                                                                                                            BTW, the above URL is a perfect example of how one should look like.

                                                                                                          2. 1

                                                                                                            Personally, I hate HTML in email - I don’t think it belongs there. Mainly, for the very reasons you had just mentioned.

                                                                                                            Let’s take phishing, for example - and spear phishing in particular. At an institution where I work, people - especially those at the top - are being targeted. And it’s no longer click here-type of emails - institutional HTML layouts are being used to a great effect to collect people’s personal data (passwords, mainly). With the whole abstraction people cannot distinguish whether an email, or even a particular link, is genuine.

                                                                                                            When it comes it the structure itself, all of that can be achieved with plain text email - the conventions used predate Markdown, BTW, and are just as readable as they were several decades ago.

                                                                                                            1. 1

                                                                                                              are these conventions well-defined? is there some document which describes conventions for stuff like delimiting sections of plain text emails?

                                                                                                              1. 1

                                                                                                                are these conventions well-defined? is there some page which describes conventions for stuff like delimiting sections of plain text emails?

                                                                                                            2. 1

                                                                                                              It’s just that I acknowledge that I have become a fossil as the times have changed.

                                                                                                              Well, there are just too many of us fossils to acknowledge this just yet.

                                                                                                            1. 9

                                                                                                              “Morgan, can you close your laptop and talk with the guests?” It had been such a simple request that Morgan could not help but acknowledge it. Had he known what manner of troubles he would bring upon himself, he might have complied, or at least used a visual editor.

                                                                                                              1. 14

                                                                                                                This blog post: a case study in being a jerk to someone who is being a jerk, only since Linus is a “jerk” you get off scott-free. Unsurprisingly, this is written by someone who has never contributed to the Linux kernel and who was uninvolved in the discussion he’s picking apart.

                                                                                                                The revised email at the end does lose information. Contrary to what hipsters write blog posts complaining about, 99% of Linus’s emails are cordial. The information that’s lost is the conveyance that this is more important to Linus than most subjects.

                                                                                                                1. 20

                                                                                                                  This comment: a case study in being a jerk to someone who is being a jerk to a jerk.

                                                                                                                  In all seriousness, I don’t believe that Gary Bernhardt is being a jerk at all. There’s a line between being critical of a piece of work and calling someone brain damaged, and hopefully, we all can see the difference.

                                                                                                                  Aside: I love when people use the word “hipster” to invalidate other viewpoints. Apparently, there are two modes of being: Being Right and Being A Hipster.

                                                                                                                  1. 2

                                                                                                                    To the unserious comment, I don’t think I was being a jerk. I called him a jerk, which I guess you could argue is a jerk move under any circumstances, but if I’m being a jerk then so is Gary.

                                                                                                                    To the serious comment, I just want to note that “brain damaged” is a meme among old school hackers which isn’t as strong of a word as you think.

                                                                                                                    To the aside, I don’t use hipster as an insult or to imply wrongness, but I do use it to invalidate his point. Gary is a Ruby developer. Linus is a kernel developer. The worlds are far removed from each other.

                                                                                                                    1. 50

                                                                                                                      I’ve put tens of thousands of lines of C into production, including multiple Linux kernel drivers. In one case, those kernel drivers were critical-path code on a device used in strain testing the wings of an airplane that you might’ve flown in by now.

                                                                                                                      I’m not a stranger to the kernel; I just left that world. Behavior like Linus’ in that email was part of the reason, though far from the only reason.

                                                                                                                      With all of that said: having written a bunch of systems software shouldn’t be a prerequisite for suggesting that we avoid attacking people personally when they make programming mistakes, or what we suspect are programming mistakes.

                                                                                                                      1. 10

                                                                                                                        Exactly. I’ve also met many people that do high-performance, embedded, and/or safety-critical code in C that are more polite in these situations. Linus’ attitude is a separate issue from what’s necessary to evaluate and constructively criticize code.

                                                                                                                      2. 17

                                                                                                                        “brain damaged” is a meme among old school hackers which isn’t as strong of a word as you think.

                                                                                                                        Yikes. That “meme” is a whole other thing I don’t even care to unpack right now.

                                                                                                                        I don’t use hipster as an insult or to imply wrongness, but I do use it to invalidate his point. Gary is a Ruby developer. Linus is a kernel developer. The worlds are far removed from each other.

                                                                                                                        Gotcha. Kernal developer == real old-school hacker. Ruby developer == script kiddie hipster. Are we really still having this argument in 2018?

                                                                                                                        1. 2

                                                                                                                          Yikes. That “meme” is a whole other thing I don’t even care to unpack right now.

                                                                                                                          “Brain damaged” is a term from back in the Multics days, Linus didn’t make that one up for the occasion. If you’re unfamiliar with the “jargon file” aka hacker dictionary, you can see the history of this particular term here: http://www.catb.org/jargon/html/B/brain-damaged.html

                                                                                                                          1. 1

                                                                                                                            Yikes. That “meme” is a whole other thing I don’t even care to unpack right now.

                                                                                                                            Listen, cultures are different and culture shock is a thing. I’m in a thread full of foreigners shocked that customs are different elsewhere. You better just take my word for it on “brain damaged” because you clearly aren’t a member of this culture and don’t know what you’re talking about.

                                                                                                                            Gotcha. Kernal developer == real old-school hacker. Ruby developer == script kiddie hipster. Are we really still having this argument in 2018?

                                                                                                                            How about you quit putting words in my mouth? Do you really need me to explain the world of difference between Ruby development and kernel hacking? In 2018? It’s not a matter of skill. Gary is great at what he does, but it has almost nothing to do with what Linus does. The people who surround Gary and the people who surround Linus are mutually exclusive groups with different cultural norms.

                                                                                                                            1. 20

                                                                                                                              You can’t use “it’s our culture” as a panacea; calling someone an idiot, moron etc. is a deliberate attempt to hurt them. I guess if what you’re saying is, “it’s our culture to intentionally hurt the feelings of people who have bad ideas,” well, then we might be at an impasse.

                                                                                                                              1. 21

                                                                                                                                The kind of toxic exclusivity and “old school hacker culture” elitism that you’re spouting in this thread is not what I expect to see on Lobsters. It makes me genuinely sad to see somebody saying these things and it also makes me apprehensive of ever being involved in the same project or community as you. Software development today is not what it was 20 –or even 5– years ago. Today it is far more about people than it is about software or technology. You may not like this, but it is the reality.

                                                                                                                                1. 7

                                                                                                                                  Lobste.rs always had a few vocal people like this in threads. But note that they’re in the minority and generally are not upvoted as much as the people who aren’t elitist, racist, or just generally being a jerk.

                                                                                                                                  1. 5

                                                                                                                                    “old school hacker culture” elitism

                                                                                                                                    Near 40, I can agree to be called old. But not elitist.
                                                                                                                                    And I cannot accept to be associated with racist.

                                                                                                                                    Not all software developers are hackers. Not all hackers are software developers.

                                                                                                                                    Is stating this “elitism”? Is it “racism”? Is it being “jerk”?
                                                                                                                                    Or is just using terms properly?

                                                                                                                        2. 5

                                                                                                                          The information that’s lost is the conveyance that this is more important to Linus than most subjects.

                                                                                                                          So add “I want to stress that this issue is really important to me” at the end of the revised email.

                                                                                                                          I think that making an issue out of this particular information being lost is missing the point - that it would be possible to say the same thing as Linus did without being abusive.

                                                                                                                          Contrary to what hipsters write blog posts complaining about

                                                                                                                          You’re falling into the same trap that the post discusses. This derision isn’t necessary to make your point, and doesn’t make it any stronger - it just adds an unnecessary insult.

                                                                                                                          1. 9

                                                                                                                            Contrary to what hipsters write blog posts complaining about, 99% of Linus’s emails are cordial.

                                                                                                                            That may well be true, but do we need that last 1% in a professional setting?

                                                                                                                            1. 9

                                                                                                                              (I am not defending Linus’ behaviour here, please don’t put those words in my mouth.)

                                                                                                                              I strongly take issue with American ideas of “professionalism”, and an even more so with the idea that we get to decide whether this project is “a professional setting” or not. What exactly makes this a “professional setting”? What is a “professional setting”? Why do we hold some interactions to higher standards than others?

                                                                                                                              I suspect “money changing hands” is the thing that makes this “a professional setting”, and that grinds my gears even further. Why are we supposed to hold ourselves to different standards just because some people are getting paid for doing it?

                                                                                                                              1. 3

                                                                                                                                Right, “professionalism” implies that you only need to be nice to somebody when you want them to something for you or want their money. This should actually be about “respect”, whether or not you want a Linux contributor to do something for you or want their money.

                                                                                                                              2. 12

                                                                                                                                The Linux kernel is not a professional setting. Besides, I argue that the 1% is useful, even in a professional setting - sometimes strong words are called for. I’ll be That Guy and say that people should grow a thicker skin, especially people who weren’t even the subject of the email and have never been involved in kernel development.

                                                                                                                                1. 14

                                                                                                                                  If I look at who the contributors to the Linux kernel are, it would certainly appear to be a professional endeavor.

                                                                                                                                  A large chunk of contributions to the kernel are made by people who are getting paid by the companies they work for to contribute. Sounds like a professional setting to me.

                                                                                                                                  1. 4

                                                                                                                                    Linux development is only “a professional endeavour” (which is a phrase I have strong issues with, see above) because some people decided to build their businesses in Linus’ craft room. We can like or dislike Linus’ behaviour, but we don’t get to ascribe “professionalism” or lack thereof (if there even is such a thing) to Linus’ work or behaviour, or that of any of the contributors.

                                                                                                                                    Even if “professionalism” is an actual thing (it’s not; it’s just a tool used by people in power to keep others down) it’s between the people doing the paying, and the people getting the pay, and has nothing to do with any of us.

                                                                                                                                    This idea that people should behave differently when there’s money involved is completely offensive to me.

                                                                                                                                    1. 7

                                                                                                                                      But it’s not. It’s a collaboration between everyone, including professionals and hobbyists. The largest group of kernel contributors are volunteers. On top of that, Linus doesn’t have to answer to anyone.

                                                                                                                                      1. 8

                                                                                                                                        So, having a hobbyist involved means that you can be dickhead? Is that the conclusion that should be drawn from your statements?

                                                                                                                                        1. 3

                                                                                                                                          No. I’m saying that Linus is not a dickhead, Linux is not a professional endeavour, and neither should be held to contrived professional standards.

                                                                                                                                          1. 2

                                                                                                                                            “I’m saying that Linus is not a dickhead”

                                                                                                                                            His comments are proving otherwise given the main article shows the same information could’ve been conveyed without all the profanity, personal insults, and so on. He must be adding that fluff because he enjoys it or has self-control issues. He’s intentionally or accidentally a dick. I say that as a satirist whose a dick to people that give me headaches in real life. Although it doesn’t take one to know one, being someone whose always countering dicks and assholes with some dickish habits of his own makes what Linus is doing more evident. If no mental illness, there’s little excuse past him not giving a shit.

                                                                                                                                            1. 5

                                                                                                                                              “doesn’t behave according to my cultural norms” == “mental illness”

                                                                                                                                              Seriously?

                                                                                                                                              I would really appreciate it if you could stop expecting that your cultural norms have to apply to everyone on the planet.

                                                                                                                                              1. 1

                                                                                                                                                Im identifying the cultural norm of being an asshole, saying it applies to him at times, and saying the project would benefit if he knocked if off. Im not forcing my norms on anyone.

                                                                                                                                                Your comment is more amusing giving someone with Linus’s norns might just reply with profanity and personsl insults. Then, you might be complaining about that. ;)

                                                                                                                                                1. 1

                                                                                                                                                  Then, you might be complaining about that. ;)

                                                                                                                                                  No, I’d just accept that people from different cultures behave differently.

                                                                                                                                                  Let’s face it, most people hate getting told they are wrong, regardless of the tone. That’s just how we are as humans.

                                                                                                                                                  Taking offense about the tone just seems very US-specific, as they are accustomed to receiving some special superpowers in a discussion by uttering “I’m offended”.

                                                                                                                                                  Some of the best feedback I received in my life wouldn’t be considered acceptable by US standards and I simply don’t care – I just appreciate the fact that someone took his time to spell out the technical problems.

                                                                                                                                                  Here is a recent example: https://github.com/rust-lang/cargo/pull/5183#issuecomment-381449546

                                                                                                                                                  1. 1

                                                                                                                                                    Here is a recent example: https://github.com/rust-lang/cargo/pull/5183#issuecomment-381449546

                                                                                                                                                    I’m not familiar with Rust, so maybe I’m missing crucial context, but I read this feedback as firm but unproblematic overall. Compared to Linus’ email:

                                                                                                                                                    • Comment admits that there are multiple points of view, gives case for their take on it.
                                                                                                                                                    • Focuses on the problems at hand rather than speculating on characteristics of any individuals involved, beyond acknowledging other viewpoints.
                                                                                                                                                    • Doesn’t include any personal insults.
                                                                                                                                                    • Doesn’t include any profanity that I noticed, certainly not gratuituous profanity.

                                                                                                                                                    It could be nicer, sure. But it seemed respectful, in the “you can do what you’re doing but consider these things:” kind of way…? The author event went out of their way to acknowledge being unconstructive.

                                                                                                                                                    To my reading it seemed closer to Gary’s email than Linus’.

                                                                                                                                                    To put it another way: if Linus wrote emails like this (only shorter, probably) then I don’t think Gary would have written a blog post about it.

                                                                                                                                                    (For the record: I’m not American, but I do fall on the gee-it’d-be-great-if-Linus-stopped-abusing-his-colleagues side of this debate.)

                                                                                                                                                    1. 1

                                                                                                                                                      I didn’t intend to imply that this was comparable to Linus’ mail, but that people who would be offended by Linus’ writing would also be offended by that comment.

                                                                                                                                                      It’s a slippery slide where every honest-to-go comment that expresses real feelings starts getting replaced by “this is an interesting idea, but did you consider …” corporate lingo, even if the code is horribly wrong.

                                                                                                                                                      1. 2

                                                                                                                                                        I didn’t intend to imply that this was comparable to Linus’ mail, but that people who would be offended by Linus’ writing would also be offended by that comment.

                                                                                                                                                        I understand this is your point, but I think there is no evidence for this. The people complaining about Linus’ conduct are complaining about specific things, and these things are not present in the comment you linked.

                                                                                                                                                        Did anyone in the Rust community (generally considered a “nicer” community than kernel development) raise concerns about this comment?

                                                                                                                                                        There is a difference between “not overtly nice” and “openly abusive”, even accounting for cultural context.

                                                                                                                                                    2. 1

                                                                                                                                                      Then you and I arent that different in how we look at stuff. Ive just layered on top of it a push for project owners to do what’s most effective on social side.

                                                                                                                                                2. 2

                                                                                                                                                  I believe it’s intentional. He does not want to be bothered by nurturing the newbs, so he deters them from going to him directly and forces them to do their learning elsewhere.

                                                                                                                                                3. 2

                                                                                                                                                  These numbers suggest it is a professional endeavor:

                                                                                                                                                  https://thenewstack.io/contributes-linux-kernel/

                                                                                                                                                  1. 2

                                                                                                                                                    Those numbers just break down the professionals involved, and don’t consider the volunteers. If you sum the percentages in that article you get around 40%. Even accomodating for smaller companies that didn’t make the top N companies, that’s a pretty big discrepancy.

                                                                                                                                          2. 6

                                                                                                                                            Linus himself is working in a professional capacity. He’s employed by the Linux Foundation to work on Linux. The fact he is employed to work on an open source project that he founded doesn’t make that situation non-professional.

                                                                                                                                      1. 2

                                                                                                                                        I’ve read the README twice and I’m still confused. Why would you use or need this? Is it decoupling of sending an receiving mails to a “list”? This lets you send to the list without being subscribed and read it via not-email? Did I get that right?

                                                                                                                                        Also:

                                                                                                                                        If a reader loses interest, they simply stop syncing. How is stopping syncing of NNTP easier than unsubscribing?

                                                                                                                                        1. 4

                                                                                                                                          These seem to be the advantages:

                                                                                                                                          • Browsing messages that were sent prior to your subscribing to the list, with a better interface (native nntp reader) than the usual web archives.
                                                                                                                                          • Keeping track of a discussion on a high volume list for a little while without having to subscribe, set up mailbox filtering, and later unsubscribe.

                                                                                                                                          However to be fair, some mailing lists already do provide mbox files of the archives that you can download and browse with a local email program.

                                                                                                                                          1. 1

                                                                                                                                            Thanks, especially that second point makes sense. What I usually do is make a bookmark on my bookmarks bar for that and delete it again after a week or month. But I do that so rarely that it’s a good enough hack.

                                                                                                                                            Also I wonder if now (hey, it’s 2018) the amount of people actively using NNTP isn’t such a low number that this is kinda moot. Also I always get the vibe of ML-hate not from people old enough to be staunch NNTP fans, but from younger people. So are the “MLs are ok, but NNTP is better” folks really even less than the “I only use NNTP”, both hardly noticeable against something else? ;)

                                                                                                                                          2. 2

                                                                                                                                            I consider this a feature:

                                                                                                                                            git clone --mirror https://public-inbox.org/meta/
                                                                                                                                            

                                                                                                                                            It creates a local copy of the mailinglist named “meta”. The local copy contains all the metadata you may need to restore the “meta” mailing list if it gets censored, for example.

                                                                                                                                          1. 1

                                                                                                                                            I think these kind of articles miss the point. It’s never been difficult to setup your own code hosting. 15 years ago many shared hosting services would even include Subversion and CVS hosting with web support for free as part of their hosting service.

                                                                                                                                            The problem is letting other people find, use and contribute to your project. For me personally, if a project isn’t on GitHub, BitBucket, or GitLab the chances of me even thinking about contributing are about zero.

                                                                                                                                            Obviously, that’s not important to everybody, but it’s something to think about.

                                                                                                                                            1. 1

                                                                                                                                              For me personally, if a project isn’t on GitHub, BitBucket, or GitLab the chances of me even thinking about contributing are about zero.

                                                                                                                                              Can you explain why that is? I’ve been thinking about self hosting projects vs using github, and am trying to think of specific weaknesses in the self-hosting option, or reasons it would deter would-be contributors.

                                                                                                                                              1. 1

                                                                                                                                                It’s a combination of laziness on my part and the fact that I don’t make many large contributions to other people’s projects. I have accounts on those services, and I know the generally accepted workflow for opening pull requests and getting changes submitted. The time from me saying, “Hey, this is a small bug I can fix,” to writing the code and opening a pull request can be as little as 5 minutes.

                                                                                                                                                But with somebody’s self-hosted Git repos, I don’t automatically know what the process is. Sometimes they’ll say, and sometimes they won’t, but it’s almost always more work than the third party hosts and it’s potentially different for everybody’s self-hosted code.

                                                                                                                                              2. 1

                                                                                                                                                My problem with GitHub at least is the fact that they inflict a double standard. They want everyone to open source their code, which I completely stand behind, while keeping a large proportion of their own codebase proprietary and closed. Not only that, but for the other two, the fact you have to pay for access to certain chunks of a service I host myself does not agree with me. If i’m hosting something, it’s all or nothing, not to mention they are all massively bloated and dependency-heavy

                                                                                                                                              1. 2

                                                                                                                                                Thankfully beginners can now use “mental compression” on dirty, dirty SQL and can save that precious mental filesystem for information about Ruby meta-programming.

                                                                                                                                                1. 1

                                                                                                                                                  You can mark clean_and_die as noreturn. I’m assuming that your compiler supports C11. You will need to include the stdnoreturn.h header.

                                                                                                                                                  1. 1

                                                                                                                                                    Cool tip. I also marked listen_forever that way. (I hope C11 support is pretty widespread these days.)

                                                                                                                                                    1. 1

                                                                                                                                                      It is pretty easy to add a macro for systems that don’t support noreturn.
                                                                                                                                                      Here is an example from one of my projects.
                                                                                                                                                      #ifndef NORETURN_H
                                                                                                                                                      #define NORETURN_H
                                                                                                                                                      #ifdef __cplusplus
                                                                                                                                                      #define NORETURN [[noreturn]]
                                                                                                                                                      #else
                                                                                                                                                      #define NORETURN noreturn
                                                                                                                                                      #include <stdnoreturn.h>
                                                                                                                                                      #endif
                                                                                                                                                      #endif

                                                                                                                                                  1. 3

                                                                                                                                                    Two things:

                                                                                                                                                    • consider using more const char * for functions that do not mutate their arguments
                                                                                                                                                    • consider passing the extra field of the pgNotify object as an argument to the shell command (so you can send message) more details here

                                                                                                                                                    Note that you probably want to write the payload to a temporary file and spool it to the shell command instead of inserting it directly, because of security concerns.

                                                                                                                                                    EDIT:

                                                                                                                                                    For the payload thing, maybe also consider fork and execlp for passing args.

                                                                                                                                                    1. 3

                                                                                                                                                      consider using more const char * for functions that do not mutate their arguments

                                                                                                                                                      I don’t want to pick nits, but since people may learn from this comment, I’d argue for going full char const * const, like this:

                                                                                                                                                      -void           listen_forever(PGconn *, const char *, const char *);
                                                                                                                                                      +void           listen_forever(PGconn *, char const * const, char const * const);
                                                                                                                                                      

                                                                                                                                                      I also can’t find a good reason for BUFSZ to be a file scope int. Usually it’d be defined with a #define. Used like that it has a side effect of the char sql[7 + BUFSZ + 1]; becoming a VLA unless gcc decides otherwise.

                                                                                                                                                      1. 2

                                                                                                                                                        Neither of those are necessary. The * const is trivially inferable and no optimizing C compiler worth anything will generate a variable length array from a const int. BUFSZ may be completely eliminated by the link time optimizer as well, since this module will have an initial executable storage class.

                                                                                                                                                        cc: @friendlysock

                                                                                                                                                        1. 1

                                                                                                                                                          The * const is trivially inferable

                                                                                                                                                          In a simple file like this it probably is trivial, but in larger projects I find it easier to follow the code when both pointers and objects pointed to are const-qualified (assuming neither should be modified by the program).

                                                                                                                                                          1. 1

                                                                                                                                                            I agree it’s useful as documentation to the developer, and as a safeguard against developer mistakes. But it doesn’t help the optimizer. And the last const qualifier on a pointer is local to the function, so it’s only useful for larger / more convoluted functions. I think any time the developer can easily see whether the pointer could be labeled const, it’s unnecessary. If it’s not easy to see, and the function can’t be quickly refactored to make it easier to see, then yeah throw a const on it.

                                                                                                                                                        2. 1

                                                                                                                                                          Good point! I’m a little lazy on const stuff sometimes. :(

                                                                                                                                                        3. 1

                                                                                                                                                          Thanks for the tips. I changed the functions to using const char * for their arguments. For the second point, this program doesn’t actually pass the payload to the command it executes. That’s all the functionality I needed for my own use case but I can see how sending the payload to the command via stdin or something could be useful in certain cases.