1. 1

    Is this project related to the rust people trying to get gcc as backend for rustc ? Or is this a new compiler for rust without any relation ?

    1. 2

      This blog post is about gccrs, a completely new Rust compiler written in C++.

    1. 5

      I see a lot of posts on Firefox vs Chrome (or in this case Chromium) and it always seems to be people lobbying for others to use Firefox for any number of moral or security reasons. The problem that I see with a lot of this is that Firefox just isn’t as good of a user experience as Chromium-based browsers. Maybe Mozilla has the best intentions as a company, but if their product is subjectively worse, there’s nothing you can really do.

      I’ve personally tried going back to Firefox multiple times and it doesn’t fulfill what I need, so I inevitably switch back to Vivaldi.

      1. 10

        This is really subjective. I tried using ungoogled-chromium but switched back to Firefox. I used Vivaldi for a while but switched to Firefox as well. Before I was using the fork of Firefox called Pale Moon but I got concerned with the lack of updates (due to how small is the team).

        1. 2

          Sure it is, but almost 80% of the world is using a chromium browser right now and Firefox is stagnant at best, slowly losing ground. Firefox even benefits from being around longer, having a ton of good will, and some name recognition and it still can’t gain market.

          1. 8

            It also didn’t get advertised everytime you visit Google from another browser. It also isn’t installed by default on every Android phone.

            1. 8

              Firefox also isn’t installed by default by a bunch of PC vendors.

              1. 1

                Firefox already had its brand established for years before that happened. It’s also worth noting that Microsoft ships with its browser (which is now a Chromium variant, but wasn’t until recently) and doesn’t even use Google as the search engine, so the vast majority of new users don’t start with a browser that’s going directly to google to even see that message.

                1. 2

                  And yet they start with a browser and why replace something if what you have already works discounting those pesky moral reasons as if those are not worth anything.

              2. 4

                Among technical users who understand browsers, sure, you might choose a browser on subjective grounds like the UX you prefer. (Disclaimer: I prefer the UX of Firefox, and happily use it just fine.)

                Most people do not know what a browser even is. They search for things on Google and install the “website opener” from Google (Chrome) because that’s what Google tells you to do at every opportunity if you are using any other browser.

                When some players have a soap box to scream about their option every minute and others do not, it will never matter how good the UX of Firefox is. There’s no way to compete with endless free marketing to people who largely don’t know the difference.

                1. 1

                  If that were the case, people would switch back to Edge and Safari because both Windows and MacOS ask you to switch back, try it out again, etc every so often.

                  The UX of firefox is ok (they keep ripping off the UI of Opera/Vivaldi though fwiw and have been doing so forever), but it functionally does not work in many cases where it should. Or it behaves oddly. Also, from a pure developer perspective, their dev tools are inferior to what has come out of the chromium project. They used to have the lead in that with Firebug, too, but they get outpaced.

            2. 1

              Yeah, I switched to Firefox recently and my computer has been idling high ever since. Any remotely complicated site being left as the foreground tab seems to be the culprit.

            1. 8

              Panicking should not unwind. Just abort. Always.

              I know that there are use cases for unwind-on-panic, just like there are use cases for move constructors, green threads, and fork(). But all of these impose a peanut butter cost that every generic algorithm, optimization pass, formal proof, all have to put in work to support. It doesn’t carry its weight.

              1. 1

                Hm, I think I disagree relatively strongly, with two points:

                I don’t think panics impose unavoidable cost. There’s option to require that panic aborts, so, eg, formal proofs can just require that the code is compiled with panic=abort.

                I also feel that supporting unwinding is important for a large class of important applications. In most long-running state full program you need catch_panic around internal boundaries for reliability. rust-analyzer relies heavily on this ability, as well as any HTTP server.

                I can see that, if we restrict Rust to pure systems software (and write our IDE and Web stuff in Kotlin), than no unwinding has a big appeal, but Rust is much more than just systems programming.

                1. 1

                  Isn’t panic-handling required to “gracefully” handle out-of-memory situations?

                  1. 1

                    In one form it is, and falls under “internal boundaries for reliability”.

                    But in a strict sense (as in, “kernel drivers should never die on OOM) you probably want just use failable (Result-returning) allocations everywhere. For that, you don’t need unwinding.

                    1. 1

                      I was under the impression (potentially incorrectly) that much of the standard library doesn’t have the ability to use failable allocations, but just panics on OOM.

                      Again, I don’t know that I’m correct.

                      1. 1

                        You are mostly correct. It’s even worse than that: at the moment, std aborts (rather than unwinds) on OOM.

                        std is just written with the assumption of a global infallible allocator. That’s a reasonable assumption for things std is intended for. The current custom allocators work will make this a bit more flexible, but won’t change the basic apis.

                        If you need to handle alloc failure 100%, you need different APIs which expose allocations to the caller.

                  2. 1

                    In my experience writing a couple of long running stateful programs, catching panics never seems like a good idea.

                    Inevitably there is some shared state somewhere, and that state is negotiated via mutex locks (or similar).

                    Panics will just leave the entire thing in a big unknown with potentially poisoned locks.

                    I might be missing the point, but it seems to me rust panics are quite similar to some Java practices where one just turns an irrecoverable problem into a RuntimeException and hope the problem is solved somewhere else.

                    1. 1

                      Inevitably there is some shared state somewhere

                      I don’t think it’s universally inevitable. Off the top of my head, here are some examples where panic recovery seems to work well in practice:

                      • Erlang
                      • web servers
                      • IntelliJ ides
                      • rust-analyzer (*)

                      So it seems that panic recovery works for some things and doesn’t work for others? This seems like a reasonable hypothesis to me.

                      Just slapping catch_panic everywhere won’t magically make a program reliable, quite the contrary. First, you need to architecture it in a way that it actually has reliability boundaries. And this is primarily about state management.

                      For example, if you make state updates transactional, then only the code that applies transaction writes can’t recover after a panic, but that’s a tiny fraction of code. For example, rust-analyzer’s state is guarded by a single mutex. If panic happens in a place where we .write it, directly on the main loop, than analyzer just crashes. But literally any part of the compiler can panic, and this won’t corrupt state or crash the process, because compiler only calculates derived data.

                      (*): there was a single case where our catch_panic bit us in the back rather painfully but that was due to a compiler bug. Initially, we had out catch_panic and all was good. Then, at Rust all hands, incremental compilation started to non-deterministically fail. The failure was traced to the trait’s system co-inductive reasoning for auto-traits like unwind-safe. So, to work-around this bug, we added AssertUnwindSafe as a way to short-circuit compiler’s trait inference. After that, chalk started to cache state, which actually wasn’t UnwindSafe. So we spend some time debugging mysterious runtime failures, which could have been caught at compile time, but alas.

                1. 3

                  People expect to easily dismiss the menu. Dialog elements, unless you include javascript, don’t seem to handle clicking outside, no longer hovering, or hitting escape. That’s the only reason I rarely use details for more than buttons requiring two clicks to activate (for more dangerous functionality)

                  1. 1

                    Is there a solution that allows this without JS? It seems a shame to throw out something where the basics work without JS just because some extended functionality doesn’t.

                    1. 1

                      Sure, you can add the rest of the functionality with JS. That’s what GitHub does.

                      1. 1

                        It doesn’t look like JS is necessary for click-outside-to-close. The slide I linked to in my comment shows an example of it. I tried it just now by turning off JS using Firefox dev tools, then closing the menu and the modal by clicking outside, and it closed! The modal was a bit funny though, the X button didn’t work, but clicking outside did.

                        That said, I didn’t look into how it works yet!

                  1. 5

                    So… apparently, you can trust that Apple Silicon is bug-compatible with Intel processors? Or is this a case where IEEE requires “incorrect” results for floating-point math?

                    1. 20

                      I’m pretty sure these results are expected based on the floating point standard. They’re mathematically incorrect because of limitations of the standard and the fact that you’re effectively rounding on each step.

                      1. 11

                        Still pretty annoying how “incorrect results” gets thrown around without any explanation or qualification. It feels more like a click-bait for (Apple) commenters to dunk on Intel … which is exactly what seems to happen in the comments already:

                        this somehow feels like a deliberate decision on Apple’s part. I mean replicating Intel’s errors on a very different architecture.

                        1. 1

                          I believe Apple (and other recent Arm) FPUs can generate three kinds of incorrect results:

                          • Incorrect results as specified the rounding modes defined by IEEE 754
                          • Incorrect results as specified the rounding modes defined by EcmaScript
                          • Incorrect results that are compatible with some x87 / SSE rounding modes
                        2. 3

                          Well, ‘mathematically incorrect’ again suggests these results are incorrect or that what happens is somehow not ‘mathematical’. I think such terminology muddies the waters. These results are not in the least incorrect. They are exactly what a calculation using mathematically well-defined finite precision representations of numbers, as specified in IEEE754, should result in.

                          What’s incorrect is the expectation that such algorithms should converge to the analytical solution.

                          1. 2

                            Please consult Kahan on the original context of these traps. Kahan’s claim is that we must do error analysis if we want to understand the results that we get from IEEE 754 algorithms.

                      1. 7

                        I belive that this article will interest more people: https://www.fsf.org/news/statement-of-fsf-board-on-election-of-richard-stallman

                        The thing with a statement like this is that I’m afraid it won’t change anyone. I see it as a reafirmatiom of RMS honesty, others won’t. I wish the conversations around these topic would become more “civilised” (for lack of a better word), so that some concensus can be reached.

                        That being said, I wonder what influence the open letter and the support letter had on all of this. It seems the letter of support has currently twice as many signatures as the one criticising RMS, which is supprising. Then again, I was also amused to be reminded of how small the actual community of people who actually care about these things (pro or contra) are.

                        1. 37

                          It seems the letter of support has currently twice as many signatures as the one criticising RMS, which is surprising.

                          As a signer of the original letter, the signatures in the original letter matter a lot more than the counterletter.

                          The counterletter was drafted in 4chan /g/ (I saw the thread where people were drafting it) and heavily promoted in the Eastern Bloc at first. It was posted in several Russian-speaking link aggregation sites as well as 4chan itself. Sure, it has more numbers… by a bunch of people who are not writing the free software we are using. In the original letter I see people who wrote the software I’m using, people I have collaborated in bugs with, people I have met at Debconf and Pycon. I see organisations that make free software. In the counterletter I see some personalities like esr and a lot of angry Russians who are upset that someone is telling them that women are having a bad time in free software.

                          A few of the signers of the counterletter managed to get some troll signatures, in Russian and 4chan references, into the original letter. They were trying to prove that this meant that there were no safeguards in the original letter and were arguing that by forcing github usernames, their signatures were more valid. Whenever I discovered these troll signatures using my limited Russian, I pointed them out and they were removed. So there were some quality checks.

                          Number of signatories doesn’t mean anything. The original letter even stopped accepting signatures while the counterletter kept accepting them. It’s quite easy to get a lot of people in favour of any cause if you frame that cause as being some version of “free speech”, regardless of the speech being said and regardless of all of the people RMS has alienated from free software, especially women.

                          1. 16

                            heavily promoted in the Eastern Bloc at first

                            I am very troubled by this. Why are opinions of free software developers in the Eastern Bloc (or Asia, for that matter) any less valid? Blend2D (a random example) is a great free software, isn’t it? Speaking as an Asian. Thanks.

                            1. 6

                              I’ve explained this elsewhere, but judging from comments they have made in Habr and presumably 4chan, their motivations are linked to anti-women, anti-LGBT initiatives common in Russia and other Slavic countries. They tend to frame kindness initiatives that do not directly benefit men as some sort of Western degeneracy. This is why their opinions on why Stallman should be head of the FSF matter less.

                              Also, Stallman just hasn’t toured Russia that much; most of them have probably never had to deal with him much or work with him. They don’t know him like we do.

                            2. 9

                              The way I see it, both the people around the open letter and the support letter can be divided into two respective groups. The open letter have those honestly concerned about the negative influence of Stallman on the perception of the FSF/Free Software in general, just like there are those who are honestly concerned about the integrity of the FSF/Free Software when it comes to preserving user freedoms. The second groups are respectively those who are interested in undermining Free Software and those invested in Culture-War issues issues regarding Free Speech, as you mention. The interesting thing is that both “sincere” sides will probably overestimate and focus on the latter groups. An issue structured like this will naturally lead to a cultural deadlock.

                              What I wonder is why you think that the open letter is in itself more legitimate than the support letter, because you recognize more developers you know. To some degree it should be expected that people you agree with will more likely be on the same side of the issue. Ultimately it would seem to me that considering that Free Software and user freedom isn’t something that should just interest developers, but users too, even if they don’t have great reputations or have met friends at conferences.

                              Either way, because of the deadlock and the arguing about “numbers vs. legitimateness”, I don’t think that these two sides will agree on anything. It is but another trench in this virtual conflict. All I can do is wonder if this influenced the FSF in any meaningful way.

                              1. 26

                                The original letter are people writing free software. I don’t know what the counterletter people are doing, but they’re not, for the most part, working on GNU, Debian, openSUSE, gcc, nor are they FSF members or employees or hardly anything of the sort.

                                This matters.

                                Btw: I don’t think anyone is interested in undermining free software. This is a conspiracy theory promoted by the counterletter authors and supporters, that somehow if we don’t want Stallman it must mean that we want to be serfs to FAMANG.

                                I support free software. I don’t have to support Stallman to do so.

                                1. 14

                                  Setting aside that there are Free Software contributors that sign the support letter,

                                  • Andrea Corallo (GCC developer, Emacs developer)
                                  • Eli Zaretskii (GNU Emacs maintainer)
                                  • Leah Rowe (Libreboot Project Leader)

                                  to name a few I recognize, next to members of the same projects you mention – I repeat my question: Why does it matter?

                                  1. 9

                                    Yes, there are some. If we go by “voting members” of the free software world, so to speak, there are way more in the original letter than the counterletter.

                                    No orgs have signed the counterletter either.

                                    1. 7

                                      Again, why does this matter?

                                      1. 26

                                        Demonstrably it didn’t. Neither letter mattered. The FSF did whatever it wanted.

                                        But for me it mattered. It showed that there is a clear consensus of people I want to work with. We agree on who we no longer want to be in charge or be a philosophical beacon for us.

                                        1. 11

                                          I think the open letter mattered a lot by starting the discussion and making it clear that a lot of people have a problem that he rejoined the board.

                                          The support letter shows that a lot of his followers have no problem about any of his opinions or thoughts as long as he did a lot of great work.

                                          1. 5

                                            Demonstrably it didn’t. Neither letter mattered. The FSF did whatever it wanted.

                                            That is what I was wondering. Did the surprising outcome of the support letter help the FSF make their decision? The reason I use the word “surprising” is that in most cases, the “right” and “wrong” sides of these discussions are quickly established, the insinuation of a majority is made on various social media platforms and the change is pushed through (such as with Stallman in 2019 or with the Linux Kernel before). I actually expected the support letter to have far less traction, whether because the position is less popular of because it is more risky to voice support for that side. The previous chapter of the controversy had the “Joint Statement” to state opposition to Stallman. The other side didn’t have anything of that sort.

                                            Ultimately this is all speculate and doesn’t amount to anything, but it is an interesting shift (or problematic tendency, depending on your interpretations).

                                            1. 17

                                              it is more risky to voice support for that side

                                              There is no greater risk to signing the counterletter. This is another conspiracy theory pushed by the counterletter, that there is a great cabal of worldwide cancellists who will harm you if you publicly support Stallman. That you need to have great bravery to sign the counterletter.

                                              I have no hard numbers, but I believe in actuality the signers of the original letter have received more abusive emails. I got a lot when I signed the GNU joint statement asking for RMS to be removed from leadership in 2019. I’m actually really afraid about having signed the original letter. I am afraid someone will get very angry and try to track me down to my home or something like that. Well, I am not sure how likely this could be, but there’s a lot more undirected anger in the counterletter than the original letter, aimed at a vague and nebulous “cancel culture”. The original letter’s anger is more focussed on a single individual who has been holding back free software for decades.

                                              1. 14

                                                Not a conspiracy theory at all. I may not be hired for choosing to sign the pro-RMS letter:

                                                https://twitter.com/jhulten/status/1376360925809106951

                                                A tool to “block” signers of the pro-RMS letter: https://github.com/travisbrown/octocrabby

                                                There’s even a browser extension to highlight signers, anywhere we show up.

                                                But sure, go on. “Cancel culture” doesn’t exist!

                                                1. 13

                                                  You’re afraid of not being hired by… some dude. I’m afraid of someone showing up in my home and trying to harm me. How many angry and threatening emails have you gotten? I got about about five in 2019.

                                                  I’m also a little afraid of not being hired by some people for having signed the letter; similar compilations exist for those who signed the original letter.

                                                  1. 4

                                                    Yes, cancel culture does exist.

                                                    However most tech companies are not bigoted enough to respect these “cancel” lists, and I’ve never seen sufficient evidence to the contrary. As to the ones who are, you would not want to work with them anyway.

                                                    Also, I predict that the future will be less woke.

                                                    1. 9

                                                      “Cancel culture” always existed, in the sense that there were entities with the power to arbitrarily take away your reputation, your livelihood, even your basic rights. Historically those entities have been major institutions such as governments and large corporations, and they have done so as a reaction against increasing liberalism.

                                                      Unsurprisingly, most of the people who now loathe and decry and bemoan “cancel culture” come down on the conservative/reactionary side and are primarily reacting to the democratization (or threat thereof) of the ability to inflict consequences based on someone’s speech, actions, associations, etc. which has been brought about by technology. When I was young, you needed a major media organization (or two or three) behind you to really “cancel” someone effectively. Now you just need a Twitter account and for what you say to catch on with enough other people. To people who were used to being the only ones wielding this power, it likely feels terrifying and so they want to treat it as a new thing. But it is simply the thing they always did, now made available to many others via technology’s ability to amplify voices, improve coordination, etc.

                                                      As to your last point, it’s worth noting that while the traditional predictor of someone’s politics (on a generic liberal <-> conservative spectrum) has been their age, it appears that is now changing and the most reliable predictors are becoming things like education level (higher education -> overwhelming more liberal tendency) and race/ethnicity (“white”/European-descended -> overwhelming more conservative tendency). So you might want to recalibrate the confidence of your prediction, especially based on a claim that measures within a young and still-developing generational cohort many of whom have not yet attended university.

                                                      1. 4

                                                        The preference of one or more organizations to avoid associating with people who publicly support someone with a behavioral track record like Stallman’s is not bigoted.

                                                        To describe it as such feels dishonest, and ignores the fact that people have legitimate concerns over how likely it is for someone who explicitly supports Stallman’s viewpoints to work in the kinds of inclusive and diverse environments that modern companies and communities seek to cultivate.


                                                        As for your prediction, I don’t think it’s very likely that the future will be less “woke”; the tweet you reference appears to be from a group that’s quite politically conservative if you go by the recent content on their timeline, so there’s quite a bit of potential for bias there.

                                                        In my experience, the tech communities that seem to be growing the most rapidly seem to focus heavily on the mind of inclusivity that I associate with “woke culture” (e.g, JavaScript and Rust).

                                                        By comparison, communities that try to stay “apolitical” (in their own words, not mine) seem to attract more abrasive and disruptive contributors who do nothing to help their relevance.

                                                        1. 10

                                                          Painting over 6000 people as being automatically opposed in some form to inclusivity, just because they stand against the witch hunt of RMS, and then seeking to “cancel” them is the very definition of bigotry (”intolerance toward those who hold different opinions from oneself”). It is also disingenuous to suggest that any organizations doing the cancellation is doing it only as a “preference”, as if there is no political / mob pressure behind the scenes.

                                                          As for your allusion to a group being (according to you) politically conservative, that only seems to be a discrediting tactic used so as to avoid having to address the central point (the statistics quoted in the tweet).

                                                          1. 9

                                                            It is not a witch hunt. He’s not a witch. He’s a guy who has demonstrably harmed free software in many ways. He was a terrible boss at the FSF (for example, refused to give raises because his logic is that wages would then increase without bound, bankrupting the FSF), he has creeped out many women, he has yelled and lost his temper at the very people who are trying to support his cause, he has defended zoophilia, pedophilia, and necrophilia, his main activism is ineffective language nitpicking and advocating technological abnegation.

                                                            Not wanting him in charge is not the same as wanting him burned at the stake.

                                                            And please don’t make me come up with links for all of these things. It’s really tiring to have to be an archivist for all of these things. Look them up yourself and if you can’t find them, then I’ll try to help.

                                                    2. 2

                                                      I thought about what happens if I would sign the open letter a bit and since a few days I get spam about GNU and Linux related topics which are oddly or very close related to RMS. One mail even had the fake sender address of Adolf H. (Yes, the one you think)

                                                      1. 5

                                                        Daniel Pocock has been spamming people on both lists lately. The guy is a figure.

                                                        1. 3

                                                          FWIW I have been receiving the same messages.

                                                          1. 2

                                                            Oh? Are people mass-emailing the counterletter signers with angry notes? What have you gotten?

                                                            I seem to be flying under the radar this time, but I attracted a lot of anger in 2019.

                                                            1. 1

                                                              The RMS open letter, not the support one AFAIK.

                                                    3. 4

                                                      It took me a good night’s sleep to realize that you’re still evading my question. So I’ll rephrase it one more: Why should it matter? Why do the voices of software users who see Stallman as someone who defends their Freedoms matter less than those of (some) developers.

                                                      1. 13

                                                        Oh, that’s what you were asking:

                                                        They matter less because they haven’t actually directly dealt with him. They haven’t worked on software he has tried to have a voice in, they haven’t seen him at conferences, they haven’t had him directly yell at them.

                                                        They don’t know him. So their opinions of him are less well-founded.

                                                2. 7

                                                  More names here:

                                                  https://www.debian.org/vote/2021/vote_002

                                                  I count 20 people seconding one of “Support Stallman’s reinstatement, as in rms-support-letter.github.io” and “Denounce the witch-hunt against RMS and the FSF” proposals,

                                                  1. Adrian Bunk [bunk@debian.org] [mail]
                                                  2. Norbert Preining [preining@debian.org] [mail]
                                                  3. Jonas Smedegaard [js@debian.org] [mail]
                                                  4. Ying-Chun Liu [paulliu@debian.org] [mail]
                                                  5. Barak A. Pearlmutter [bap@debian.org] [mail]
                                                  6. Adam Borowski [kilobyte@debian.org] [mail]
                                                  7. Micha Lenk [micha@debian.org] [mail]
                                                  8. Michael Biebl [biebl@debian.org] [mail]
                                                  9. Bart Martens [bartm@debian.org] [mail] [confirm]
                                                  10. Jonas Smedegaard [js@debian.org] [mail] [confirm] [confirm] [confirm]
                                                  11. Pierre-Elliott Bécue [peb@debian.org] [mail]
                                                  12. Daniel Lenharo [lenharo@debian.org] [mail]
                                                  13. Milan Kupcevic [milan@debian.org] [mail] [confirm]
                                                  14. Michael Biebl [biebl@debian.org] [mail] [confirm]
                                                  15. Axel Beckert [abe@debian.org] [mail]
                                                  16. Gilles Filippini [pini@debian.org] [mail] [confirm]
                                                  17. Filippo Rusconi [lopippo@debian.org] [mail]
                                                  18. Shengjing Zhu [zhsj@debian.org] [mail]
                                                  19. Matteo F. Vescovi [mfv@debian.org] [mail] [confirm]
                                                  20. Mathias Behrle [mbehrle@debian.org] [mail]
                                                  1. 12

                                                    These aren’t votes yet. These are seconds, for various of the proposals, both for and against and various shades in between. This is how Debian does resolutions. The votes will be finalised by Saturday.

                                                    1. 8

                                                      both for and against and various shades in between.

                                                      The 20 Debian folks I included however were all for (not against) supporting Stallman. I only included it (and this is only from Debian) because you wrote “the counterletter people are [….] not, for the most part, working on GNU, Debian, openSUSE, gcc,”.

                                                      1. 11

                                                        That’s not entirely how that works; they’ve seconded the resolutions to appear on the ballot, not voted for them specifically. Seconding it just means they think it should appear as an option, not that they agree with it.

                                          2. 8

                                            It seems the letter of support has currently twice as many signatures as the one criticising RMS, which is supprising.

                                            RMS has a very religious almost cult following. So no surprise there. Also the RMS open letter GitHub repo stopped accepting signatures on April 1st. The support one still accepts signatures to this date.

                                            I did a very quick look at the signers of the RMS support letter, looked at a very small amount of accounts closer and there where a couple of things that stood out and seemed fishy:

                                            • lots of Russian sounding names
                                            • some of them where newly created (for example 31. March), had their first PR against the repository or had very little activity the last year

                                            This could be coincidence or people created their account because of this letter but it could also mean that people created new account or used other means to inflate the numbers.

                                            1. 21

                                              lots of Russian sounding names

                                              As someone of Slavic descent, I would be very interested in what you mean to imply by this point.

                                              1. 16

                                                Russia has a well-documented state-sponsored homophobia. The recent Russian bill to ban gay marriage, even foreign-made gay marriage, had over 70% support in the polls. These attitudes trickle down and they’re popular with the general Russophone population, not just with the governments. A widespread belief in Slavic countries is that gay acceptance is some Western-induced degeneracy that didn’t really exist in Soviet times, along with some kind of desire to go back to the good ol’ days when LGBT people didn’t “exist”.

                                                Thus, a letter that is perceived to defend someone (RMS) who has been attacked by the LGBT community will be popular in Russia and surrounding countries. The discourse in 4chan framed the counterletter as being explicitly drafted to give trans people a kick in the head. They consistently used transphobic slurs to refer to me and other signatories of the original letter.

                                                1. 15

                                                  This is such a wild take. Heck, you could’ve said something like “they’re Russian bots” and that would be somewhat acceptable. You didn’t stop to consider that they could’ve had other motivations (so many better ones!) for having signed it? This is a very bad generalization of the Russian populace, akin to calling all Americans gun-touting redneck hillbillies.

                                                  The real reason for most of the Russian signatures was the letter being shared on some Russian link-aggregator site(s).

                                                  1. 8

                                                    No, they’re not bots, they’re real. And talking to them in the github issues of the counterletter, they are very angry about women and minorities being promoted. This seems to be a strong implicit reason for their alignment with the defense of Stallman. They want to defend their freedom of speech to be awful to women and minorities because being nice is censorship.

                                                    Of course I generalised, because we have voting numbers. At least 70% of the Russian population is homophobic.

                                                    1. 5

                                                      At least 70% of the Russian population is homophobic.

                                                      I’d really like to see what are your sources for this claim.

                                                      1. 15

                                                        I gave you the source: the voting numbers of the Russian bill passed yesterday to ban gay marriage. It had widespread support. These are not deeply-hidden facts that are difficult to find.

                                                        But here, there’s plenty more sources:

                                                        https://en.wikipedia.org/wiki/LGBT_rights_in_Russia#Public_opinion_2

                                                        If anything, I was giving Russians the benefit of the doubt with 70% It seems closer to 80%.

                                                  2. 6

                                                    Flagged as troll for being racist against Russians.

                                                    1. 10

                                                      Russian homophobia is well-documented and is a very harmful problem that is killing people in Russia. Recognising problems in Russian society is uncomfortable, but I don’t think it’s racist.

                                                      1. 6

                                                        Here’s how I understand your reasoning:

                                                        • Russian government is homophobic and polls show that many russian citizens also are (that is true)
                                                        • Many people who supported the counter-letter are from Russia (also true)
                                                        • Therefore they support RMS because they are homophobic.

                                                        You can tell me to go find it myself. But, it’s you making claims. When I’m making a claim, I’m ready to bear the burden of proof, or I say that it’s just my opinion that may be too far-fetched or entirely untrue. You present your statements as facts but are unwilling to present any proofs, and I don’t think it makes you look more trustworthy, even if your statements are true.

                                                        1. 5

                                                          The last claim comes as an inference and from statements I have seen in 4chan and Habr, in English and Russian. 4chan quite openly frames support for the counterletter as a homophobic and transphobic cause. It’s more subtle in the Habr comments, but it does happen there too.

                                                          It’s more difficult to find it in Habr because my Russian is rudimentary but if you’d like, I can do that too, in case your own Russian isn’t good enough.

                                                  3. 2

                                                    Just something I have noticed. I don’t know if FSF normally reaches those countries and if it is suspicious or not.

                                                  4. 4

                                                    lots of Russian sounding names

                                                    From what I heard, the support letter was shared around Russian HN-likes, which explains that aspect.

                                                    1. 2

                                                      Do you know if those sites tried to push people to sign the letter?

                                                      1. 9

                                                        Yes, it was posted to Habr:

                                                        https://en.wikipedia.org/wiki/Habr

                                                        I can’t find the original post, but they coordinated attacks on the original letter from Habr, for example:

                                                        https://habr.com/en/post/549276/

                                                        1. 9

                                                          Are you implying that anti-RMS people “sign open letters”, while pro-RMS people “coordinate attacks” when they do exactly the same thing? ;)

                                                          1. 5

                                                            These are the same sort of people who are trying to directly harm Molly de Blanc, getting her arrested or swatted. I won’t link to that attack, but there is a lot of anger and implied violence against the original letter. This thing posted to Habr is the same sort of angry violence, trying to get legal authorities involved.

                                                            It’s not exactly the same thing, it’s not both sides. I am not calling for Stallman to be arrested or harmed. I just don’t want him leading the FSF or GNU.

                                                            1. 7

                                                              You are accusing people of coordinating an attack and giving a link to something that clearly isn’t that (not a thread where an attack coordination took place). Then you say you won’t give a real link. Why should I believe you?

                                                              The post you linked to doesn’t call for violence towards anyone, either. Also, “calls for violence” and “calls for authorities to get involved” are kinda mutually exclusive things.

                                                              1. 7

                                                                It’s not hard to find the Molly de Blanc attack page. Look for it yourself.

                                                                Also, “calls for violence” and “calls for authorities to get involved” are kinda mutually exclusive things.

                                                                Not in the US. Swatting has gotten people killed. Swatters hope people will get killed. This is an unfortunate by-product of militarisation of the US police force: calling cops on someone can be a death sentence.

                                                                1. 4

                                                                  All respect due, that post isn’t calling for swatting. It’s calling for the removal of the issue from GitHub!

                                                                  1. 3

                                                                    I’m talking about the attack site on Molly de Blanc that I don’t want to link.

                                                                    But incorrectly citing laws on Github is a similar sort of aggression, driven by similar rage. You’re right it won’t lead to a swatting but I have seen the same group endorse both kinds of actions.

                                                            2. 3

                                                              I mean, they are literally trying to coordinate to have the original letter removed. That’s different to signing an open letter, isn’t it?

                                                              1. 6

                                                                It’s a copy of the deleted issue that someone posted there after the fact, and it received a whole three comments (all general remarks about the situation, no specific action proposals). Since that post clearly is not about coordinating an attack, I assumed JordiGH is referring to something else—most likely the rms-support-letter itself.

                                                            3. 1

                                                              The issue reads like some spam I get daily 😀

                                                        2. 4

                                                          Who cares where they’re from? What matters is whether they’re just random names, or if they’re actively involved in the business of the FSF (and, therefore, are more likely to know what they’re talking about).

                                                        3. 2

                                                          It seems the letter of support has currently twice as many signatures as the one criticising RMS, which is supprising.

                                                          I don’t know. It seems to me that pretty much nobody knows who RMS is, and a significant portion of those who do don’t care about him. So it makes sense that the ones who bother to do something about it are the ones who support him.

                                                        1. 11

                                                          GPL’ed header files are now holed below the waterline.

                                                          1. 8

                                                            So is windows.h. That’s probably a good thing, over all.

                                                            1. 1

                                                              windows.h has been independently re-derived a number of times, making it a nonissue regardless.

                                                              1. 3

                                                                How are those cases different from what Google did with Java?

                                                                1. 5

                                                                  Copyright protects your work from being copied by others. If I look at the windows.h that microsoft distributes and use that as a basis for my own windows.h, it’s possible that what I produce constitutes a derivative work that thus infringes on microsoft’s copy rights. (This is what google v oracle was about.)

                                                                  However, if I derive the windows api in the context of a clean room, the result is not a derivative work and thus not infringing. This, for instance, is what the wine and reactos projects have done, and wine expressly prohibits people who might have had contact with windows source code from contributing for this reason.

                                                                  1. 1

                                                                    What if you clean room derive a 100% identical header?

                                                                    (Not impossible if the original, say, didn’t have comments and was formatted with a tool like clang-format which you’ve also decided to use…)

                                                                    1. 2

                                                                      clean room derive a 100% identical header?

                                                                      Then that’s fine, as long as you didn’t copy it from the original.

                                                                      1. 1

                                                                        Or better put, where do you draw a line between clean room based development output vs an actual system you are converting?

                                                                    2. 2

                                                                      The work that Oracle claims is copyrighted in this case is the “Structure Sequence and Organization” of the APIs, which is a term they created that somehow includes things like names.

                                                                      I presume Moonchild’s point is that people have reversed the windows ABI into an API many times, and the ABI doesn’t include the requisite elements to be copyrightable even if Oracle is right that their API is copyrightable. I’m not sure I agree with that argument, but it is an interesting one.

                                                                2. 2

                                                                  Shit, hadn’t thought of that. Good catch.

                                                                  1. 2

                                                                    Even if they’re C++ libraries where everything is in the header file?

                                                                    (You just know some court’s going to be unable or unwilling to distinguish between declarations and code.)

                                                                    1. 1

                                                                      I don’t know, this is a massive fair use question! You would have to show that there’s broad knowledge of the header file contents in particular.

                                                                      Java being Java is where the fair use conclusion came in. Millions of people knowing The Java API definitions! I think it’s non controversial to state that Java APIs are more universally known than almost anything under the sun

                                                                      And this case in the outset is like “look this is complicated and fast moving, we’re going to state stuff here but don’t consider it broad in scope”. Pretty tough fight to win IMO

                                                                    1. 29

                                                                      Linux productivity software is fine, but there are rough edges for the power user

                                                                      Interesting. For me, it is the exact opposite. I used Linux as my main desktop from 1994 to 2007. In 2007 I switched to macOS as my main desktop OS. The last few years I have slowly been moving back to Linux as my main desktop. After a short adventure with the M1 MacBook Air, I decided that the Mac ecosystem is definitely on a trajectory that I don’t like anymore, and returned the M1 Mac and sold my last Intel Mac.

                                                                      What I like about the Linux desktop is that it is so much beter for the power user. Better profiling (perf), better observability (eBPF, yes there is DTrace, but the eBPF ecosystem is so much more exiting), better customizability, better development tools, better package managers, native containers, etc.

                                                                      What I dislike is the lack of high-quality productivity software (and since when are e-mail clients and calendaring apps not productivity software?). Sure, we have LibreOffice, GIMP, Inkscape, Scribus. But I would love to be able to use Microsoft Office, the Affinity Suite, OmniGraffle, etc. Many productivity apps are just too far ahead of open counterparts. So, even though I moved away from the Mac, I now have to keep a Windows partition around to run Microsoft Office.

                                                                      1. 13

                                                                        yes there is DTrace

                                                                        FWIW DTrace is completely broken out of the box on OS X. Apparently it’s fixable but you have to disable SIP. This makes me extremely sad.

                                                                        If I find myself in the position of needing to understand something very weird that a piece of software is doing, if it’s portable across unices then it’s sometimes easiest to run it in a Linux VM since things like strace actually work there. :(

                                                                        1. 6

                                                                          When something isn’t working on my Linux workstation I similarly take it over to an illumos VM where truss and DTrace are available haha, so I know the feeling.

                                                                          1. 1

                                                                            Not going to lie, I think I’d be tempted to do the same if I did know dtrace (and to a lesser extent illumos, but eh I assume it’s well made enough to not be difficult).

                                                                            I don’t because of a lack of familiarity with the tools.

                                                                            When I’m using Linux I still miss ftrace from BSD. strace is great except that the probe effect is so bad.

                                                                        2. 12

                                                                          What I dislike is the lack of high-quality productivity software (and since when are e-mail clients and calendaring apps not productivity software?).

                                                                          This is something I’ve noticed as well. Linux developers prioritize things that they’re interested in (perf, eBPF, DTrace), meaning that the stuff that they don’t care about (productivity software, especially email) lags behind Windows/macOS by years (if not decades) - but commercial developers won’t port their stuff to Linux, because (in addition to the market being small) Linux users have been habituated to not pay for software!

                                                                          I’m inclined to say that this is a product of the FSF’s rabid anti-commercial-software propaganda, but maybe there’s another reason.

                                                                          1. 12

                                                                            I think it’s simply more to do with power structures – like, the Mac has a good email client, because someone at Apple pays people to make it, and more importantly, decides what it’s going to do. Free software has tended to operate without a singular product vision, so in order to make progress, the people involved seem to try and clone what they’re familiar with.

                                                                            1. 9

                                                                              but commercial developers won’t port their stuff to Linux, because (in addition to the market being small) Linux users have been habituated to not pay for software!

                                                                              I’m inclined to say that this is a product of the FSF’s rabid anti-commercial-software propaganda, but maybe there’s another reason.

                                                                              I thought we debunked this theory when Steam came to Linux.

                                                                              The truth is that it’s just the old chicken and egg problem about small market share and market share won’t grow until peoples’ favorite software is available.

                                                                              1. 7

                                                                                Also because Valve had two really good reasons to seek out wider OS support: the Windows and Mac App Stores.

                                                                                1. 4

                                                                                  I thought we debunked this theory when Steam came to Linux.

                                                                                  Computer users have completely different expectations for games and productivity software, and are far more willing to pay for the former across every platform. Steam coming to Linux did not “debunk” that theory at all.

                                                                                  The truth is that it’s just the old chicken and egg problem about small market share and market share won’t grow until peoples’ favorite software is available.

                                                                                  Please don’t say things like “the truth is” without any irrefutable substantiating evidence.

                                                                                  Meanwhile, that’s your spin on things. I would then ask you why macOS productivity software is so much better-developed than Linux, when the former already has a tiny market share compared to Windows.

                                                                                  1. 1

                                                                                    Computer users have completely different expectations for games and productivity software, and are far more willing to pay for the former across every platform. Steam coming to Linux did not “debunk” that theory at all.

                                                                                    I agree that computer users are much more willing to pay for games across every platform. I’m not sure how that debunks my debunking. I’m asserting that Linux users are just as willing to pay for Steam games as people on any other platform (though we obviously don’t have hard data on that). If that’s true (or even close to true), then I think that does debunk the argument that they aren’t buying other software because of “being habituated to not paying for software”. Linux forums EXPLODED when Steam came to Linux. People were losing their minds to throw money at Valve. I would think that the anti-spending habituation would take time to wear off, but it did not seem to in the internet circles that I frequent (and the small handful of people I knew in meatspace that ran Linux also buy/bought Steam games).

                                                                                    Along similar lines, I don’t think I know any Windows users that are buying Microsoft Office or Adobe PhotoShop for personal use, either. It seems to me that the willingness to pay for entertainment and not for productivity software is more or less universal…

                                                                                    Please don’t say things like “the truth is” without any irrefutable substantiating evidence.

                                                                                    Fair enough. I suppose I could’ve been more clear in indicating that this was a statement of conjecture. (But irrefutable? That’s a high bar for a semi-casual discussion about human behavior, no? ;) )

                                                                                    Meanwhile, that’s your spin on things. I would then ask you why macOS productivity software is so much better-developed than Linux, when the former already has a tiny market share compared to Windows.

                                                                                    Can you give examples? I ask that genuinely, just so I can understand what we’re talking about. I do mostly run Linux on my personal machines and have a Mac for work. But I’m a software dev, so I really don’t do things like PhotoShop, Microsoft Word, etc. So I just don’t know what we’re talking about. I know that when I was in science, the Linux machines all had MATLAB and Mathematica installed on them. Those are pricey.

                                                                                    But, I can offer some hypotheses other than Linux users not liking to pay for things other than games:

                                                                                    • Apple’s market share is still a gazillion times bigger than desktop Linux’s. If there’s a threshold for when it would become profitable to support a platform, it’s entirely conceivable that Macs have crossed that threshold and Linux has not.
                                                                                    • Related to the above point, there isn’t even one Linux platform. It’s probably harder to develop (and distribute) for Linux than either of the other major platforms. These days it is probably easier with Snap and Flatpack and whatnot, but historically this has not been true. So the cost would be higher to port to Linux than to port to Mac, for example.
                                                                                    • The “chicken and egg” scenario that I mentioned before.
                                                                                    • Similar to the “chicken and egg”, but maybe people who use Linux don’t need the same kind of productivity software for the ways they are productive with their machines. For example, I know several people who run Linux and pay for IntelliJ licenses. So, even if $TOTAL_NUMBER_OF_LINUX users was large enough, there still just aren’t enough of them who want PhotoShop functionality to make it worth it.
                                                                                2. 3

                                                                                  the stuff that they don’t care about (productivity software, especially email) lags behind Windows/macOS by years (if not decades)

                                                                                  Another thing may be is that if you have been using Linux for most of your life like me, I have no idea what this productivity software has to offer me. E.g. I can use Email, send and recieve messages, send plaintext messages, my client understands the headers, etc. That is what I imagine Email to be. What would an Email-Salesman tell me to change my mind, and switch to some propriatory client that is entierly different?

                                                                                  1. 2

                                                                                    People who don’t want to pay can do this via piracy as well, and also take advantage of anybetter software that may not have a counterpart on Linux. Also, free software is not about not paying. If the values of free software collide with the commercial intentions of software developers does not mean that the former is propaganda against the latter.

                                                                                    1. 2

                                                                                      People who don’t want to pay can do this via piracy as well

                                                                                      Piracy happens on Linux too - so now you have two reasons why your application won’t make as much money. (well, three, but the third (tiny market share) isn’t relevant)

                                                                                      If the values of free software collide with the commercial intentions of software developers does not mean that the former is propaganda against the latter.

                                                                                      Beyond the general “values of open-source”, the FSF in particular (which I specifically mentioned) has engaged in anti-commercial-software propaganda.

                                                                                    2. 2

                                                                                      the stuff that they don’t care about (productivity software, especially email)

                                                                                      I think it’s a little trickier. A lot of Linux developers do care about some kinds of productivity software, but many of the people in this category are also not very excited about GUI apps, so a lot of the actively maintained and innovative software is either terminal software or even an emacs package, making it a bit inaccessible to people looking for Windows/macOS style apps.

                                                                                      For example I use mu4e as my email client for a few years now. It’s actively developed (multiple yearly releases, regular new features, quick bugfixes, etc.). In my opinion has one of the best UIs out there for a power user, but it is almost certainly not what someone migrating from Mail.app wants.

                                                                                    3. 3

                                                                                      After a short adventure with the M1 MacBook Air, I decided that the Mac ecosystem is definitely on a trajectory that I don’t like anymore

                                                                                      What didn’t you like about it? I personally love my M1 MacBook Air, but my preferences certainly aren’t universal truths.

                                                                                      1. 1

                                                                                        I feel exactly the same way, although I don’t use most of the mentioned apps (Photoshop, Calendar, Mail, etc)

                                                                                        After discovering i3 and investing way too much time customizing my shell experience I’m ready to ditch OSX for good. My maxed out ThinkPad x1 Gen8 screams relative to my maxed out 16” MBP (granted it has all the performance sucking endpoint protection spyware installed). That said, part of my day job is iOS build tools so it won’t be so easy to fully get away :)

                                                                                        1. 1

                                                                                          Do you reboot into Windows to run Office, use virtualisation software, use CrossOver, or something else?

                                                                                          1. 1

                                                                                            I switch to my laptop, which I have hooked up to the same screen. I checked the CrossOver database, from from which I inferred that e.g. recent Office versions do not really work. Running Windows in a VM would definitely be possible, but haven’t set it up yet.

                                                                                            1. 1

                                                                                              I just had a look and yes the star ratings have been dropping for the recent versions. It’s a bit of a shame because I remember using it years ago and it felt surprisingly ‘native’ - even in how snappy it was.

                                                                                              1. 1

                                                                                                Yeah, I also used CrossOver Office in the early ’00s and it was amazing. I think one of the issues is that back then, productivity applications were still pretty much shrink-wrap, static pieces of software. Nowadays, things like Office (especially with Office 365) are constantly updated and therefore a moving target.

                                                                                                I should try the VM route again, but the last time it was not that great. I really dislike VirtualBox and AFAIR graphics acceleration was not really great with SPICE. VMWare probably doesn’t work well with NixOS and Fedora.

                                                                                        1. 3

                                                                                          Not sure if it counts. Everything in the video is technically true, but the way it’s presented is still pretty funny.

                                                                                          https://www.youtube.com/watch?v=xRNXa70C3x4

                                                                                          1. 72

                                                                                            Honestly, for a general-purpose laptop recommendation, it’s hard to recommend anything but the new ARM MacBooks. […] I just hate the cult of personality around built around a ThinkPad that only exists as a shadow in a cave.

                                                                                            Do you want to tell him or shall I?

                                                                                            1. 17

                                                                                              Tell me about what?

                                                                                              My recommendations are tempered by things like Mac OS (every OS sucks in its own unique ways), but they’re the fastest laptops you can get, get actual all-day battery life without ceremony, are lightweight, and have good build quality. This is based around actually using one as my everyday laptop - Apple really has made significant improvements. Unless someone has other requirements (i.e pen, x86 virt, etc.), they’re good all-around.

                                                                                              1. 49

                                                                                                The quote is just kind of funny to read since Apple products have been almost synonymous with fanboyism and cultish followings for decades, while the thinkpad crowd has levied that exact same criticism.

                                                                                                I mean personally I don’t actually disagree with you, I think Apple makes good hardware and “thinkpad people” have gotten just as bad as “apple people” in terms of misguided brand loyalty. It’s just funny because what was quoted feels like very much a role reversal in a very long standing trend.

                                                                                                1. 27

                                                                                                  Maybe it’s just my circles but I don’t see Apple fanboyism as much as I see “anti-Apple” fanboyism.

                                                                                                  1. 44

                                                                                                    That’s because you hang out on sites like Lobsters.

                                                                                                    1. 3

                                                                                                      Honestly, the “Apple fanboys” are nowadays mostly one of those things that “everybody knows” despite not really bring true. Sure, you can find the occasional example, but you’re more likely to find a handful of mildly positive comments about Apple and then a hundred-comment subthread shitting on both Apple and “all these fanboys posting in here”. And basically any thread about laptops will have multiple subthreads of people loudly proclaiming and getting upvoted and lots of supportive replies for saying Apple is evil, Apple’s hardware and software are shit, everybody should run out and switch to Thinkpads.

                                                                                                      Which is just kind of amusing, really.

                                                                                                  2. 16

                                                                                                    The quote is just kind of funny to read since Apple products have been almost synonymous with fanboyism and cultish followings for decades

                                                                                                    Yes, and I think the M1 is a prime example of the hype, further boosted by Apple’s following. The M1 is a very impressive chip. But if you were only reading the orange site and some threads here, it is many generations ahead of the competition, while in reality the gap between recent AMD APUs and the M1 is not very large. And a substantial amount of the efficiency and performance gap would be closed if AMD could actually use 5nm production capacity.

                                                                                                    From the article:

                                                                                                    Honestly, for a general-purpose laptop recommendation, it’s hard to recommend anything but the new ARM MacBooks.

                                                                                                    Let’s take a more balanced view. The M1 Macs are great if you want to run macOS. ThinkPads (and some other models) are great if you want to run Windows or Linux.

                                                                                                    1. 12

                                                                                                      Do the competitors run fanless?

                                                                                                      I’m happy with my desktop so I don’t have a stake in this game, but what would appeal to me about the M1 non-Pro Macbook is the fanless heat dissipation with comparable performance.

                                                                                                      1. 6

                                                                                                        I mean are there actually laptops that are running super long like the M1? Even back with the Air for me Macs having reliable long batteries was a huge selling point compared to every other laptop (I know they throttle like crazy to do this, but at least the battery works better than other laptops I have owned) . I think Apple deserves loads of praise for shopping laptops that don’t require you to carry your charger around (for decent time frames relative to competition until maybe super recently)

                                                                                                        Full disclaimer: despite really wanting an M1’s hardware I’m an Ubuntu user so…

                                                                                                      2. 5

                                                                                                        I don’t have any brand loyalty towards thinkpads per se but rather the active community of modifications and upgrades. There are things like the nitropad (from nitrokey) that is preinstalled with HEADs and has some minor modifications or refurbishing as well as many other companies are selling second hand thinkpads in this way, but I think nothing beats xyte.ch (where I got my most recent laptop).

                                                                                                        The guy is an actual expert and will help you chose the modifications you want (for me I wanted to remove bluetooth, microphone, put an atheros wifi so I can use linux-libre, change the CPU to be more powerful, also the monitor changed to 4k and there were other options also.. like maybe putting an FPGA like fomu in the internal USB of the bluetooth or choices around the hard drives and ports you want) after choosing my mods and sending him 700$ he spent a month doing all my requested changes, flashing libreboot/HEADs and then fedexed it to me with priority.

                                                                                                        This was my best online shopping experience in my life and I think this kind of stuff will never exist for apple laptops.

                                                                                                        1. 3

                                                                                                          Hmm fanboyism. Must fight… urge to explain… why PCs are better than laptops. :-p

                                                                                                          1. 1

                                                                                                            Oh, I know all about the dumb fanboy shit. I’ve at least outlined my reasoning as pragmatic instead of dogmatic, I hope.

                                                                                                        2. 12

                                                                                                          I just really like running Linux. Natively, not in a VM. I have a recent P14s running Void Linux with sway/wayland and all the hardware works. I know there’s been some effort to get Linux working on the new M1 chips/hardware, but I know it’s going to be mostly out-of-the-box for modern Dell/Thinkpad/HP laptops.

                                                                                                          With Microsoft likely jumping ship over to ARM, I’m really hoping Linux doesn’t get completely left behind as a desktop (laptop) OS.

                                                                                                          1. 7

                                                                                                            It seems like some people mistake the appreciation of quality Apple hardware for a cult.

                                                                                                            1. 18

                                                                                                              It may seem like that, but isn’t. Of the two Macs I currently own, one is in for repair (T2 crashed, now won’t boot at all) and one has been (CPU would detect under voltage and switch off with only one USB device plugged in). Of the ~80 Macs I’ve ever deployed (all since 2004), five have failed within two years and a further three have had user-replaceable parts DOA. This doesn’t seem like a great strike rate.

                                                                                                              BTW I’ve been lucky and never had any of the recall-issue problems nor a butterfly keyboard failure.

                                                                                                              1. 2

                                                                                                                While I strongly prefer my Dell Precision (5520), I haven’t really had the same experiences as you.

                                                                                                                I have a work laptop which is a MacBook and gets a bit toasty - but I use it every day and have not had any issues so far.

                                                                                                                My own laptop was a 2011 MacBook Pro and it took spilling a glass of wine on it to kill it, prior to that there were no problems. Once I did break the keyboard by trying to clean it and had to get it repaired. Maybe it was getting slow and there was some pitting on the aluminium where my hands laid (since I used it every day for 6 years). It died in 2017.

                                                                                                                Those are the two MacBooks I owned

                                                                                                              2. 8

                                                                                                                There might be some selection bias at work, but I have been following Louis Rossmann’s youtube channel and I absolutely do not associate Apple with good quality.

                                                                                                                1. 5

                                                                                                                  Louis Rossman has a vested interest in repairable laptops as he runs a repair shop and Apple is actively hostile to third-party repairs.

                                                                                                                  Not saying what Apple does is good for the consumer (though it’s often why resale value of their laptops is high)- but I would assume that Louis is the epitome of a biased source.

                                                                                                                2. 5

                                                                                                                  I have used MacBooks from 2007-2020. I had two MacBooks with failing memory, one immediately after purchase, one 1-2 months after purchase. I also had a MacBook Air (pre-butterfly) with a failing key. I had a butterfly MacBook Pro with keys that would often get stuck.

                                                                                                                  The quality of average is very average. I think the number of problems I had with MacBooks is very average for laptops. However, Apple offers really great service (at least here in Western European countries), which made these hardware issues relatively painless to deal with.

                                                                                                                  1. 5

                                                                                                                    Apple doesn’t merely make good hardware, it makes Apple hardware, in that its hardware is often different from the mainstream. Butterfly keyboards, for example, or some of their odder mouse designs. it’s possible to appreciate good hardware without thinking Apple’s specific choices are worth buying, even if you concede they’re good implementations of those choices you dislike.

                                                                                                                1. 10

                                                                                                                  What I want to know is if I start learning Rust now, how confident can I be that my knowledge is applicable in a few years, or if the best practices will be deprecated until then. The impression I always get from listening into Rust conversations is that there is a lot of change going on, old compilers (such as those usually distributed by system package managers) are easily outdated making me feel like it might be better to wait a bit for the language to stabilize. Is that mistaken or is it true that Rust isn’t a stable language to learn, like C or Lisp?

                                                                                                                  1. 21

                                                                                                                    Mistaken. I started learning Rust in 2013 (pre-1.0), and most things I learned about Rust then is still applicable now and I am confident it will continue to be applicable in 5 years. Rust is a stable language that has been stable since 2015. I actually don’t recall any best practices that has been deprecated.

                                                                                                                    Hope this helped.

                                                                                                                    1. 3

                                                                                                                      I am probably not the most qualified person to answer this (i.e. i am not a rust expert), but, as i understand, rust has actually been a quite stable language since v 1.0, so i wouldn’t worry too much about stability.

                                                                                                                      I’d add to that, that in general in the software industry technologies and best practices change all the time (within reason), so I’d keep an open mind and give it a shot. If you end up liking it, I am sure you’d find ways to stay up to date with any evolution of the ecosystem without even noticing.

                                                                                                                      My 2 cents…

                                                                                                                      1. 2

                                                                                                                        old compilers are easily outdated

                                                                                                                        Rust has a rare approach to version management: they guarantee backwards compatibility of ‘stable’ features across upgrades, but expect you to always use a very recent version of the compiler (and provide automatic updates).

                                                                                                                        I’m not sold on it, personally:

                                                                                                                        • I don’t trust anyone not to introduce regressions via automatic updates. In fairness to the rust team, I’m not aware of any regressions that made it out, and they have very good automatic testing to ensure they don’t introduce any.
                                                                                                                        • If you use a library that requires ‘nightly’ (non-stable) features, your code will most likely be broken when those features change in an update.

                                                                                                                        If you want stability, install a ‘stable’ release; your code will continue to compile without modification for the foreseeable future, thanks to the ‘editions’ approach to backwards compatibility.

                                                                                                                        It’s true that there are many changes to the language in each (frequent) release, but the vast majority are “something that you would expect to work was broken, has now been fixed”.

                                                                                                                        1. 8

                                                                                                                          I used Rust in production for algorithmic trading for a year. (I have since moved on to other jobs and I no longer use Rust in production.) I was responsible for technical decisions, and I insta-updated Rust compiler as soon as releases were out. I had no problems. It does work as advertised.

                                                                                                                          1. 1

                                                                                                                            I insta-updated Rust compiler as soon as releases were out. I had no problems. It does work as advertised.

                                                                                                                            But this is what annoys me. I run apt upgrade maybe once every week or two, and would like everything to be done, having to pay attention to compiler updates because a library depends on it not something I want to see.

                                                                                                                            1. 6

                                                                                                                              The apt-provided compiler is the compiler used by Debian/Ubuntu for building their system and their packages. It is not meant for general development - especially if it involves e.g. cross-compilation - unless you target Debian/Ubuntu. If you would like that policy to be different, I recommend giving feedback to the packager team, they are a great bunch :). FWIW: This notion is far more pronounced when talking about Rust then about C, but it is also present there - the C compiler in “build-essentials” is the one used by the system. C just happens to be way more settled.

                                                                                                                              I also want to add that libraries switching to higher minimum versions is becoming rarer and rarer, I often find myself lagging the stable compiler by at least 2 versions (and that as a Rust project member!).

                                                                                                                              1. 1

                                                                                                                                If you would like that policy to be different, I recommend giving feedback to the packager team, they are a great bunch :).

                                                                                                                                Can you tell me where I can do this?

                                                                                                                          2. 7

                                                                                                                            In maintaining ggez for about four years, I’ve had compiler updates break the build twice that I can recall. Both times the breakage was in a dependency. Once it was a small but for realsies regression, once it was tightening the rules around unsafe code a little. In both cases it was a bit of a nuisance but that’s all.

                                                                                                                            IMO this is acceptable. It’s kinda hateful, but dependencies break sometimes; this is not a Rust-specific thing. If you don’t want to put up with it, don’t use them. A lot of the more stable crates outright say what the oldest version of rustc they support is, which is nice, but for something like ggez that has a huge transitive dependency tree you’re basically stuck using the most recent one.

                                                                                                                            1. 3

                                                                                                                              Using a library on nightly has been, in my experience, problematic with updating compiler versions. That’s exactly how it’s supposed to be, though.

                                                                                                                              Libraries on stable, however, have never once broken for me on a compiler upgrade, and it’s something I’ve done fairly often over the last two years using Rust in production.

                                                                                                                              1. 3

                                                                                                                                The (valid!) problem most people highlight is that if e.g. the stdlib adds a function in 1.51 and a dependency starts using it, you have to update your compiler. Given that Rust just added const generics and a lot of common libraries like heapless and bitvec have been waiting for it for a while, 1.51 is also a release that will most likely be a release where that is more pronounced.

                                                                                                                              2. 2

                                                                                                                                Rust has a rare approach to version management: they guarantee backwards compatibility of ‘stable’ features across upgrades, but expect you to always use a very recent version of the compiler (and provide automatic updates).

                                                                                                                                I’m not sure why you consider this rare. “Automated upgrades, declaring the version of the API that you want in a manifest file, and a fanatical approach to backwards compatibility” sounds like Windows 10, which might be one of the single most widely-used pieces of software in existence.

                                                                                                                                1. 1

                                                                                                                                  Rust has a rare approach to version management: they guarantee backwards compatibility of ‘stable’ features across upgrades, but expect you to always use a very recent version of the compiler (and provide automatic updates).

                                                                                                                                  I want to push back here slightly: it’s true, but this is the status quo. Currently, we support the current compiler only and rarely backport fixes. We have a lot of change control going on and ensuring the backwards compatibility here is already a task we spend much time on. But that does not mean that this policy is set in stone, but supporting older compilers requires resources and we (still) are a young language. In general, we prefer to either do things proper or not at all and currently, the needle is still on “not at all”. For that reason, I wouldn’t call it “an approach”, only “the current approach”.

                                                                                                                                  We make the approach easy by releasing often and predictably (we never missed a release date), which ensures small deltas. Plus above mentioned change control mechanism (CI, Code Review and the big hammer: crater).

                                                                                                                                  https://github.com/rust-lang/crater

                                                                                                                              1. 3

                                                                                                                                Is there a reason why Kernel support for WireGuard is important? Is it just for performance reasons?

                                                                                                                                1. 7

                                                                                                                                  Yes. Avoiding context switches for, what is essentially a virtual ethernet stack, is a giant win, at least in theory.

                                                                                                                                  1. 4

                                                                                                                                    Is that not reason enough? I’ve done RDC over a slow VPN. It’s miserable.

                                                                                                                                    1. 2

                                                                                                                                      That’s a big point.

                                                                                                                                      Having used OpenBSD’s implementation I think another big point might be that this means it’s part of the base system and will likely end up being better integrated into it. If your system always ships with wg, you are more inclined to make it for example better measurable, debugable, configurable within that base system.

                                                                                                                                      That’s less true for the Linux world where everything is seen in a more stand-alone fashion, so I guess there it’s more about distributions or tool builders embracing the use case.

                                                                                                                                    1. 7

                                                                                                                                      Functional programming is a tribe. It’s not a school of thought, but a school of behaviors and attitudes towards people.

                                                                                                                                      1. 12

                                                                                                                                        No, functional programming is a style of programming in which you prefer to write functions without side-effects, with an emphasis on immutability.

                                                                                                                                        1. 5

                                                                                                                                          For me the key difference is that when imperative, I feel like carver or stonecutter with regard to the data I work with. When functional, I feel like I’m growing the data from the inside.

                                                                                                                                          1. 4

                                                                                                                                            Is SQL functional then?

                                                                                                                                            1. 3

                                                                                                                                              I’ve always thought of SQL as declarative than imperative (or functional).

                                                                                                                                              1. 1

                                                                                                                                                It feels similar to me, yeah. Definitely much closer to LISPs and Haskell than to Python or C.

                                                                                                                                                I realize it’s mostly about whether I think in expressions or statements.

                                                                                                                                          2. 4

                                                                                                                                            OK, I’ll bite :-) What do you mean with “Functional program is … [about] attitudes towards people”?

                                                                                                                                            1. 3

                                                                                                                                              Programming tribes operate by cultural values which emphasize treating people according to their style of writing code. The common pattern for these tribes is to indicate that code is good, bad, etc. according to certain abstract principles which are either nebulous, trivial, undefinable, or subjective; and then to use these judgements to establish social ranking and attitudinal norms.

                                                                                                                                              Crucially, these opinions are almost entirely arbitrary. For an on-topic example, every “immutable” language has a mutable machine which implements its semantics by reifying the execution stacks implied by its internal logic, and every “mutable” language has an immutable denotational semantics given by its native type theory. This leads directly to e.g. the weasel words in a cousin comment, “an emphasis on immutability”, as if computer science were not already part of mathematics and mathematicians did not already regularly treat time as yet another varying parameter.

                                                                                                                                              1. 3

                                                                                                                                                I think there’s a lot of truth to this, and I agree with the sentiment, so take these as questions to explore your thoughts further…

                                                                                                                                                and then to use these judgements to establish social ranking and attitudinal norms.

                                                                                                                                                Absolutely. But I don’t think exclusively.

                                                                                                                                                Crucially, these opinions are almost entirely arbitrary.

                                                                                                                                                Did you mean to imply that arbitrary meant “without value” here? The words of our many natural languages too are arbitrary, and serve tribal goals, but the tribalism also serves to get a bunch of people on the same page to accomplish shit.

                                                                                                                                                For an on-topic example, every “immutable” language has a mutable machine which implements its semantics by reifying the execution stacks implied by its internal logic, and every “mutable” language has an immutable denotational semantics given by its native type theory.

                                                                                                                                                This feels like a technically correct but (at least partially) irrelevant fact to me. Is your argument that as a programmer you don’t experience a substantial difference between C and Haskell? People talk about having a functional or imperative “mindset” – tribal motivations aside, this does not strike me as an imaginary difference. In another answer puffnfresh made this empircal point:

                                                                                                                                                there are large groups of programmers who DO use the term to mean just programming with (mathematical) functions. You can ask a question in these groups “is this functional?” and get a consistent response; it has meaning!

                                                                                                                                                Forget the value argument, which language is better, etc. I’m just interested if you really think there is no difference in the experience of writing and reading those languages, or how you think about that.

                                                                                                                                                1. 6

                                                                                                                                                  Did you mean to imply that arbitrary meant “without value” here?

                                                                                                                                                  I mean to say that any desired value can be assigned as a judgement. Imagine a video game: The representations displayed on-screen are simulacra designed to remind the player of various symbols which they know from outside the game, but the inner logic of the game is only aware of bits and basic arithmetic operations. This sort of disconnection is called a “ludic barrier”. Similarly, there is a cultural barrier which separates the intuition for how a language appears to operate from the actual native type theory which governs its computation. On one side of this barrier, “immutable” is an opinion rather than a fact, and that opinion is grounded in memes rather than in formal proof.

                                                                                                                                                  And yes, words are arbitrary in this sense, with the barrier being both ludic and cultural; this was Wittgenstein’s massive insight which led him to develop the discussion around language games.

                                                                                                                                                  This feels like a technically correct but (at least partially) irrelevant fact to me. Is your argument that as a programmer you don’t experience a substantial difference between C and Haskell?

                                                                                                                                                  No, my argument is that Haskellers tend to share a memeplex, an interlocking collection of memes which undergirds a culture. For example, Haskell has plenty of mutability (IO, ST, STM all offer mutable references) but the meme is that Haskell’s data is always immutable. This Haskell culture imagines itself as part of a larger tribe which affiliates with other functional-programming cultures.

                                                                                                                                                  Another strong example, which should be food for thought but is instead usually pearls before swine, is that we are not programming with functions and sets. We can only compute the effective things, and we need to pay attention to what we can and cannot realize on a computer. (There are generalizations of functions, like those offered by category theory and the category of sets (WP, nLab); we can use a function-like environment to talk about computable functions and partial functions.) The top comment thread was right to point out the implications for computational complexity theory.

                                                                                                                                                  I’m just interested if you really think there is no difference in the experience of writing and reading those languages, or how you think about that.

                                                                                                                                                  All Turing-complete programming languages are Just Another Programming Language to me. I agree that the experience of expressing oneself in each distinct language is different, and further that there may be overlap in language features which leads to overlap in experiences. But I’m not willing to actually sign on to the poor definitions of “experience” and “feature” which folks usually are imagining in these sorts of discussions; experience is too hard to talk about still, and features are usually oriented around marketing rather than around shared fragments of type theory.

                                                                                                                                                  Put another way, I think that programming language design is almost entirely about UX and ergonomics, and choice of computational models only matters to the degree that it eases or frustrates the programmer’s ability to emulate that model and predict how the computer will interpret their expressions.

                                                                                                                                                  1. 1

                                                                                                                                                    Thanks.

                                                                                                                                                2. 1

                                                                                                                                                  …whereas you, on the other hand…

                                                                                                                                                  1. 3

                                                                                                                                                    Whereas I am allied with mathematics and logic. I feel that all Turing-complete programming languages have something to teach us, but that no Turing-complete language is perfect for any particular task. (There are interesting esoteric languages which challenge this, like HQ9+.)

                                                                                                                                                    It happens that, when we combine mathematics and anthropology, we prove that we are all quite closely related, and that tribalism is thus an unnecessary and outdated framework for how we should conduct ourselves. When we find tribal urges within ourselves, we need to also dig deep and find empathy which can let us overcome tribalism in favor of proper multiculturalism.

                                                                                                                                                    1. 2

                                                                                                                                                      That’s asking for too much. Tribalism is fine for now, we just need to elevate representatives that are not embarrassing, you know; cooler heads prevail - and all that… With time maybe we’ll be able to blur the lines a bit more.

                                                                                                                                                      1. 3

                                                                                                                                                        I really don’t think it is, and I actually think this tribalism is holding us back. Tribalism around programming language puts pressure on individuals to choose a style; are you in the “functional” camp or the “bare-metal” camp? And given how arbitrary these distinctions are, we instead end up spending cognitive load on trying to figure out which camp a language or a person is in, rather than trying to more effectively look at the aesthetic benefits and tradeoffs the language provides. With less tribalism, we can explore the aesthetic space of Turing-complete (and Turing-incomplete!) languages and freely mix features of whatever programming styles we like into a mix of aesthetics that we feel will elevate the practice of programming. Rather than bikeshedding about whether Prolog is functional, declarative, or OOP, we can instead spend time asking ourselves what happens if we invent completely new programming paradigms that hit our aesthetic preferences better.

                                                                                                                                                        On this very site, if you look at the disowned posts (posts by deleted users who have chosen to hide their username on their post), there’s a markedly higher percentage of posts about Go and C in the disowned group. What this implies, to me, is that some aspect of the community here has driven away the people that like to talk about Go and C. This, to me, is a sad thing. Learning is a collaborative activity and our shared experiences and explorations help drive research and practice forward. By creating a fractious environment you end up driving away the very activity that helps elevate the aesthetic goals of programming.

                                                                                                                                                      2. 2

                                                                                                                                                        I like math. I like that you like math. I like that you know way more about math than me. I like to understand your point of view. I don’t like being flagged, but I’m going to risk digging myself a little deeper by drawing your attention to the following irony:

                                                                                                                                                        1. Tribes establish common values and cultural norms.
                                                                                                                                                        2. The way you use phrases like “weasel word,” “allied,” “unnecessary and outdated,” and “how we should conduct ourselves,” is normative.
                                                                                                                                                        3. The way I was flagged as a troll in an invitation-only forum is normative.
                                                                                                                                                        4. A tribe that has a shared opinion about programming language design is, by definition, also a school of thought. Dismissing it as not a real school of thought because you reject its opinion is normative.

                                                                                                                                                        I understand that tribes do ugly things. But the notion that you or any human being is completely above tribalism is, to put it as gently as I can without drawing further ire, inaccurate. We just demonstrated that in this very thread. Furthermore, the fact that mathematics are capable of perfect internal consistency does not preclude mathematicians from normative, tribal behavior within their discipline.

                                                                                                                                                        1. 2

                                                                                                                                                          Just to be clear, I’m the one who downvoted you as “troll”, not Corbin. And I stand by my judgement: calling out Corbin for criticizing people’s tribal behaviours while still engaging in them is an appeal to hypocrisy. If being subject to tribal instincts made Corbin unfit to criticize tribal attitudes, then nobody in the world would ever be able to except psychopaths.

                                                                                                                                                          It’s also the kind of comment that’s guaranteed to bring out a defensive response, which is the actual definition of trolling. And the resulting thread, with its defensive attitudes and STEMlords-arguing-about-the-humanities topic is basically guaranteed to be frustrating and boring.

                                                                                                                                                          1. 2

                                                                                                                                                            I appreciate your perspective. I might not be able to give it the respect that it deserves, but that is my personal failing. I did not feel that you were unfairly curt with your first post; you made an excellent point that speared the heart of a problem that undermines my entire position. Socrates would be proud.

                                                                                                                                                            I might be doing some sort of moral philosophy here, but I certainly don’t mean to imply that I’m somehow unaffiliated; I actively produce an object-based functional programming language, I spent years in the Python and Haskell communities, and I am not immune to propaganda. Of course I am a problematic and flawed person with a limited and broken perspective, hobbled by my own experiences and words. That does not mean that my critiques are useless; it means that I am subject to my own critiques.

                                                                                                                                                            For what it’s worth, I will never flag you. I will always use my words to explain why I disagree with you. Also, for what it’s worth, by opening up this thread, I got at least three new flags and became the sixth-most-flagged user, earning the pink banner; this is not my highest score, but it’s close.

                                                                                                                                                      3. 1

                                                                                                                                                        Interesting. So are you saying that it’s only folks that enjoy or explore the functional style of programming that are like this? Or are all styles of programming tribes that are about attitudes towards people?

                                                                                                                                                        1. 3

                                                                                                                                                          There’s at least a few more tribes that are easily recognizeable:

                                                                                                                                                          • Object-oriented programming: Computation is about objects, which are combinations of state and behavior that send messages to each other. The goal of computation is to have a network of interacting objects.
                                                                                                                                                          • Assembly/bare-metal programming: Computation is about digital logic. The goal of computation is to go as quickly as possible.
                                                                                                                                                          • Esoteric language design: Computation is about the technical details that make languages Turing-complete. The goal of computation is to be artistically expressive and to ponder the nature of computation.
                                                                                                                                                          • UML diagramming: Computation is about the high-level nebulous relationships between business concepts. The goal of computation is to execute business operations.
                                                                                                                                                          • Type-driven design: Computation is about types. The goal of computation is to simplify type-theoretic expressions and verify type-based proofs.

                                                                                                                                                          In all of these cases, I’ve seen the memes extend from judgment on code to judgment on people.

                                                                                                                                                          This doesn’t happen with all programming styles. For example, Wang tiles or Conway’s Game of Life can be Turing-complete, and it’s easy enough to imagine a programming tribe which insists that computation is about shapes and that the goal of computation is to have aesthetically-pleasing memory layouts, but I’ve not yet seen people judging each other because of their attitudes towards such tiled languages.

                                                                                                                                                          1. 2

                                                                                                                                                            That’s a fascinating perspective. Over the years, I’ve certainly seen passion, but I wouldn’t reach the same stark conclusion “functional programming is about attitudes towards people” as you. Of course, you’re welcome to think that, but I don’t.

                                                                                                                                                            1. 1

                                                                                                                                                              I think the memes of life and wang tiles are similar to those of the esoteric programming languages, insofar as the goal is not practicality but the digging of turing tarpits largely for personal edification.

                                                                                                                                                    1. 32

                                                                                                                                                      I totally get what the OP is saying. I want technology that is stable, sustainable, liberating, and which respects my autonomy. But the only way we get there is free software. Not corporate-driven open source, and certainly not proprietary software. I wonder if Unix-likes are really the best foundation for building that future; I suspect they might not be.

                                                                                                                                                      If you care about old hardware and alternative architectures, Apple isn’t your best bet. They only target whatever Apple is selling. They’re a hardware company; software is their side-hustle. Well, hardware and now rent-seeking in their gated community, by means of the app store. They’re also a company built on planned obsolescence and “technology as fashion statement”.

                                                                                                                                                      As for stability, most of the big players don’t care, because the incentives aren’t present. The tech field has inadvertently discovered the secret of zero-point energy: how to power the unchecked growth of an industry worth trillions of dollars on little more than bullshit, a commodity whose infinite supply is guaranteed. Surely, this discovery warrants a Nobel Prize in physics. As long as the alchemists of Silicon Valley can turn bullshit into investments from venture capitalists, there will be no stability.

                                                                                                                                                      For what it’s worth, I use an iPhone. It’s a hand-me-down; I wouldn’t have bought it new. It’s an excellent appliance, but I know that when I use it, Apple is in the driver’s seat, not me. And I resent them for it.

                                                                                                                                                      1. 10

                                                                                                                                                        But the only way we get there is free software. Not corporate-driven open source, and certainly not proprietary software.

                                                                                                                                                        I was a big believe in that for a very long time, too, but I’m not too convinced that software being free is the secret sauce here. Plenty of of free software projects treat users, at best, like a nuisance, and are actively or derisively hostile to other projects, sometimes in plain sight (eh, Gnome?). There’s lot of GPL code that only has major commercial backers behind it, working on major commercial schedules and producing major commercial codebases, to the point where even technically-inclined users are, in practice, largely unable to make contributions, or meaningfully maintain community forks, even if the licensing allows it (see e.g. Chrome).

                                                                                                                                                        I’m starting to believe that free licensing is mostly an enabler, not a guarantee of any kind. No amount of licensing will fix problems that arise due to ego, or irresponsibility, or unkindness. Commercial pragmatism sometimes manages to keep some of these things in check at the product development level (which, presumably, is one of the reasons why the quality of Linux desktop development has steadily declined as less and less money got poured into it, but I’m open to the possibility that I’m just being bitter about these things now…)

                                                                                                                                                        1. 3

                                                                                                                                                          Plenty of of free software projects treat users, at best, like a nuisance, and are actively or derisively hostile to other projects, sometimes in plain sight

                                                                                                                                                          I can personally attest to this. I know it all too well.

                                                                                                                                                          largely unable to make contributions, or meaningfully maintain community forks, even if the licensing allows it (see e.g. Chrome).

                                                                                                                                                          I feel this is an argument for having slower, surer process as well. Write a spec before writing and landing something. Have test plans. Implement human usability studies for new UI features. A tree that moves slower is inherently more stable (because new bugs can’t find their way in, and old bugs have longer to be fixed before it’s rewritten) and gives more opportunity for community involvement. But I know this is a controversial opinion.

                                                                                                                                                        2. 7

                                                                                                                                                          I want technology that is stable, sustainable, liberating, and which respects my autonomy. But the only way we get there is free software.

                                                                                                                                                          The only way we get there is with a society that is stable, sustainable, and respects you autonomy. And we haven’t had that since at least the Industrial Revolution (for certain, specific quantities of stability, sustainability, and respect; those have never been absolute). The switch from craftsmanship to mass production made it kinda a lost cause.

                                                                                                                                                          1. 12

                                                                                                                                                            But the only way we get there is free software.

                                                                                                                                                            I strongly suspect that’s not really true. We have to admit that the vast majority of open-source contributors do not have the work ethic (and why would they, they’re working on open source in their spare time because it’s fun) to push a project from “it fits my needs” to “everyone else can use it”. The sad situation is that most projects are eternally stuck in the minimal viable product stage, and nobody is willing to put in the extra “unfun” 80% of work to polish them and make them easy to use and stable.

                                                                                                                                                            I know this is a problem I’m having, and I doubt I’m the only one.

                                                                                                                                                            1. 7

                                                                                                                                                              This really is the problem.

                                                                                                                                                              Nobody wants to do usability studies, even informal ones. Hell, I just gather a group of friends + my Mum and have them sit at my laptop and tell me what they like and don’t like about the FOSS I’m writing, and from what I’ve gathered my UIs are miles away better than most others.

                                                                                                                                                              Nobody wants to write a spec or a roadmap. Personally, I grew up loving discussing things and learning, and I view requirements gathering as an extension of both of those activities, so it’s really enjoyable for me.

                                                                                                                                                              I run my FOSS projects kind of like how most corps used to run corp dev (somewhere between waterfall and agile). I feel that the quality is higher than most others, though I admit it’s subjective. And, you always like what you make because you made it so it works the way you expect.

                                                                                                                                                              But in my opinion, process really is the problem. But if process was required, most FOSS wouldn’t exist, because nobody would really want to follow that sort of process in their free time. (Present company excluded.)

                                                                                                                                                              1. 7

                                                                                                                                                                I really want to see more UX designers get interested and involved in FOSS. It’s very clear that FOSS is driven primarily by sysadmins and secondarily by programmers. If we want a usable system then UX designers need to be involved in the conversation early and often.

                                                                                                                                                                1. 2

                                                                                                                                                                  … and, with the risk of being catty, when there are UX designers, they are content in copying mainstream interfaces instead of innovating and trying to produce something original.

                                                                                                                                                                  1. 3

                                                                                                                                                                    In the case of Linux, they’re oftent content copying the obviously bad examples, too.

                                                                                                                                                                2. 4

                                                                                                                                                                  Every once in a while I’ll get the up the gumption to get organized, or maybe clean the house. Then I’ll use that energy, and I’ll try to put a system in place to raise that baseline for good. Later on, when I don’t have the same zeal, whatever system I invented almost certainly fails.

                                                                                                                                                                  The only systems that seem to survive are those that are dead simple. For instance, when I must remember to bring something with me, I leave it leaning against the front door. That habit stuck.

                                                                                                                                                                  So when it comes to development process, do you think there’s some absolute minimum process that could be advocated and popularized to help FOSS projects select the tasks that matter and make progress? …Lazy agile?

                                                                                                                                                                  1. 4

                                                                                                                                                                    I leave it leaning against the front door. That habit stuck.

                                                                                                                                                                    That was a particularly vivid flashback of my teenage years you just gave me. Wow.

                                                                                                                                                                    do you think there’s some absolute minimum process that could be advocated and popularized to help FOSS projects select the tasks that matter and make progress? …Lazy agile?

                                                                                                                                                                    I’m going to have to think very hard on this one. I’m not sure what that would look like. Definitely a thought train worth boarding.

                                                                                                                                                                    1. 4

                                                                                                                                                                      So when it comes to development process, do you think there’s some absolute minimum process that could be advocated and popularized to help FOSS projects select the tasks that matter and make progress? …Lazy agile?

                                                                                                                                                                      This is why if I intend to work on FOSS that I feel might be “large” (e.g. something I can see myself working on for many months or years), I setup an issue tracker very early. For me, dumping requirements, ideas, and code shortcuts I’m taking into an issue tracker means that if I’m feeling sufficiently motivated I can power through big refactors or features that take a lot of work to add, but if I’m feeling less ambitious, I have some silly bug where I decremented the same count twice that I can fix that takes only an hour or so of my time and results in an actual, tangible win. That helps me keep forward momentum going. This is what helps me, at least.

                                                                                                                                                                      1. 3

                                                                                                                                                                        Interesting perspective. Thanks for chiming in!

                                                                                                                                                                  2. 6

                                                                                                                                                                    What are the problem areas for you? I’m genuinely curious as I have been using free open source as a daily driver for a few years now, and for a while the worst was the lack of gaming support. There are more linux specific titles on steam right now to occupy my time that I don’t even have to faff about with proton yet.

                                                                                                                                                                    I’ve been in teiresias camp now for a while, free software is the future.

                                                                                                                                                                    1. 3

                                                                                                                                                                      I am fine. I love to tinker with things even if it prevents me from “doing the work”. As a very basic example: if my network stops working after a package update, I lose the 30m-1h to find what’s wrong and fix it. However there are people in the world where this kind of productivity loss is unacceptable.

                                                                                                                                                                      I’m afraid that the open source community mostly develops for people like me (and you, from what you’re saying).

                                                                                                                                                                  3. 11

                                                                                                                                                                    The only way we get there is with a society that is stable, sustainable, and respects you autonomy. And we haven’t had that since at least the Industrial Revolution

                                                                                                                                                                    Wait, what?

                                                                                                                                                                    Since the Industrial Revolution we’ve had pretty much constantly increasing wealth, human rights, health, autonomy, throughout almost all the world:

                                                                                                                                                                    https://ourworldindata.org/uploads/2019/11/Extreme-Poverty-projection-by-the-World-Bank-to-2030-786x550.png

                                                                                                                                                                    Sub-Saharan Africa was and continues to be a basket-case, but I don’t think anyone is blaming that on the Industrial Revolution. (Actually, leaving aside the racists … what are people blaming that on? Why is it that the rest of the world is dragging itself out of povery, but Sub-Saharan Africa isn’t?)

                                                                                                                                                                    1. 4

                                                                                                                                                                      “Sub-Saharan Africa was and continues to be a basket-case, but I don’t think anyone is blaming that on the Industrial Revolution. “

                                                                                                                                                                      You’re not accounting for the possibility of linkage between the shutdown of the annual monsoon of sub-saharan africa in the 1960’s to coal-burning in europe releasing sulphur dust, which rose during the industrial revolution. Obviously there were also political-driven things out in the area back then too. See one argument here: https://extranewsfeed.com/the-climate-doomsday-is-already-here-556a0763c11d , referencing http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.652.3232&rep=rep1&type=pdf and http://centaur.reading.ac.uk/37053/1/Dong_etal_revised2.pdf .

                                                                                                                                                                      “Since the Industrial Revolution we’ve had pretty much constantly increasing wealth, human rights, health, autonomy, throughout almost all the world”

                                                                                                                                                                      Be really careful with interpreting data-driven arguments (Pinker, Rosling, ourworldindata, etc.) as truth - they’re popular in the tech world, rationalist/progress circles, 80,000 hours, etc. I find myself unlearning parts of these narratives and trying to be more open minded to less rigorous arguments these days. The argument I’ve heard is that you can have someone in earning more money (which gets recorded on paper) but they may actually be undernourished compared to smallholder subsistence living (which data may translate as living in poverty). You also have to factor in the changes in ecological function / land use change with increase of people living in an urban niche.

                                                                                                                                                                      As far as how all this relates back to free software, I don’t know enough - I see problems and interesting ideas both in free software movements and non-free software 🤷‍♂️

                                                                                                                                                                      1. 5

                                                                                                                                                                        As far as how all this relates back to free software, I don’t know enough - I see problems and interesting ideas both in free software movements and non-free software 🤷‍♂️

                                                                                                                                                                        It was just me chiming in as usual whenever anyone blames capitalism, or industry, or so-on for all the world’s ills[1].

                                                                                                                                                                        Capitalism and industry have been responsible for lifting billions out of the default state of humanity: miserable poverty, disease, and tribal warfare.

                                                                                                                                                                        And in first-world countries, we’ve gone in one generation from “one expensive, fragile, and basically toy-like 8-bit microcomputer” to “everyone in the family owns multiple computers, including hand-held battery powered supercomputers with always-on high-speed Internet connections”. 90% of Australians, for example, are regular Internet users. 90%!

                                                                                                                                                                        Meanwhile the proposed alternatives have been responsible for millions of deaths in the last century alone.

                                                                                                                                                                        [1] Hyperbole, but not far off the mark.

                                                                                                                                                                        1. 2

                                                                                                                                                                          There needs to be a middle-ground between “pure” capitalism and “pure” socialism.

                                                                                                                                                                          Both of them scare the living crap out of me.

                                                                                                                                                                          But both of them also have very good, very useful ideas that the world needs to utilise.

                                                                                                                                                                          1. 3

                                                                                                                                                                            The good ideas present in socialism (like caring for those who, through no fault of their own, are incapable of caring for themselves) are in no way incompatible with pure[1] capitalism, and are also far from unique to socialism.

                                                                                                                                                                            All that socialism implies is that people are forced to fund that care, as opposed to doing it voluntarily (through charity, mutual socities, unions, religions, etc.).

                                                                                                                                                                            To put it in hacking terms: socialism is a brute-force kluge ;)

                                                                                                                                                                            [1] By which I assume you mean laissez-faire.

                                                                                                                                                                            1. 1

                                                                                                                                                                              That type of socialism is like the GPL, in enforcing behavior that one is afraid might not happen voluntarily, given there would be the more capitalist resources available to do so.

                                                                                                                                                                              A country with mandatory private health insurances use exactly the same maths to figure out costs, yet people see that as a huge problem because the USA fscked things up. I can attest to universal health care not being universal, not systematically, as the lines are long with a heavy emphasis on anything that’s not pre-emptive, even denying treatment due to cost.

                                                                                                                                                                              That worries me, since competing companies are incentivized to keep their customers. Is that closed-source software? Maybe.

                                                                                                                                                                              But often FOSS seems to behave like this monopoly superorganism that can do whatever, like the new Gnome UI stuff. Good thing there’s at least some competition.

                                                                                                                                                                              1. 1

                                                                                                                                                                                That type of socialism is like the GPL, in enforcing behavior that one is afraid might not happen voluntarily

                                                                                                                                                                                Except that it’s unlike the GPL in that if you don’t want to use GPL software, you’re free to choose something else. If you don’t want to license your software under the GPL, you’re free to choose a different license.

                                                                                                                                                                                Socialism doesn’t give those subject to it any choice in the matter.

                                                                                                                                                                                (Edited to clarify: as currently implemented by mainstream politics. Voluntary communes and the like are just fine by me. Not how I’d choose to live personally, but a perfectly valid choice. And, note, completely compatible with laissez-faire capitalism.)

                                                                                                                                                                                1. 1

                                                                                                                                                                                  That’s a fair extension to my analogy, sure. This does certainly start to break down if people compare BSD-licensed contributions and voluntary societal ones. Sadly that often degrades quite quickly into rich people buying a clean conscience without actually giving a crap, which is a nice parallel for Google’s FOSS effort.

                                                                                                                                                                                  I do agree with you and personally don’t really care if good charity came from a bad person/party, unless there are nasty strings attached.

                                                                                                                                                                                  Edit: bad wording maybe for “bad”. Nasty strings are t&c but also you can’t buy yourself clean with money from child-trafficking. These terms are too vague and subjective.

                                                                                                                                                                      2. 1

                                                                                                                                                                        The common explanation I’ve heard in left leaning circles is that because the countries are dirt poor, they have to take loans from institutions like the IMF, and those loans have incredibly shitty agreements which basically guarantee that the country remains poor because all of the value generated in that country is shipped over to the rich parts of the world. Many of them, for example, have enough fertile land and water to keep the population fed, but that land and water is instead being used to grow cash crop for the richer countries, which is part of the reason we enjoy cheap T-shirts and coffee. There’s also a lot of other ways the current economic world order kind of screws over the poorer countries; a lot of it is described in the Wikipedia article on neocolonialism.

                                                                                                                                                                        Some people go as far as to claim that capitalism requires an underclass, so in social democracies which try to achieve some degree of equality within the nation, the underclass has to be out-sourced to places like Africa or China. (That certainly seems to be what’s happening, but whether it’s required by the economic system or just a flaw in the current implementation of it is up for debate.)

                                                                                                                                                                        Personally, I find those explanations fairly convincing, and I haven’t heard any good refutations. I’m far from an expert on the topic though, so there may be other, good explanations. My personal guess would be that the reason this topic isn’t discussed that much (at least in non-racist circles) is that we basically have to conclude that the rich parts of the world are responsible for perpetuating the problem, and that acknowledging this and fixing it would be really fucking expensive.

                                                                                                                                                                        1. 1

                                                                                                                                                                          The book The Dictator’s Handbook (summarized in Rules for Rulers) offers another explanation. Foreign aid is a quid pro quo for policy changes. Aid recipients accept the loans and use it to enrich their government’s supporters.

                                                                                                                                                                    2. 1

                                                                                                                                                                      I use an iPhone. … I know that when I use it, Apple is in the driver’s seat, not me. And I resent them for it.

                                                                                                                                                                      Can you say more about the origin of that resentment? I’ve seen versions of this perspective often and I’d like to understand where it comes from.

                                                                                                                                                                      1. 3

                                                                                                                                                                        For me, it’s a feeling of learned helplessness.

                                                                                                                                                                        If I’m using my PinePhone and there’s a problem, it’s usually something I can fix. Even if it means running the onboard diagnostics and ordering a new motherboard (yeah, my WiFi just failed), that’s an intended use case. Sure there’s a binary blob or two involved, and I can’t personally repair surface-mount boards … but to a far greater extent than either an iPhone or an Android phone, it’s my device.

                                                                                                                                                                        Contrast that with, say, an old Samsung phone. Want to upgrade the OS? You’re SOL if Samsung and/or your carrier has stopped shipping updates. Want to root the device, or swap OS? Expect a bunch of software to stop working (think Google Play, and games with overzealous anti-cheat for starters). Want to repair the device? Go buy some specialist tools and cross your fingers … but probably don’t bother, because OS updates aren’t a thing any more anyhow.

                                                                                                                                                                        1. 5

                                                                                                                                                                          but to a far greater extent than either an iPhone or an Android phone, it’s my device.

                                                                                                                                                                          It is your device if you understand and enjoy technology to that extent, and I think this is an important point to drive home. Imagine you have a friend Foo. Foo uses a Mac, but is getting real tired of their Mac constantly telling them they can’t install a piece of software or that some application of theirs can’t read from a directory. Foo hears that all their cool tech friends are on Linux, so maybe Foo should be too. Foo installs a distro, and then tries to plug in two monitors with different DPIs. Big mistake; nothing is scaled properly. Foo searches online and sees references to font scaling, HiDPI support, this thing called Gnome, and other stuff. Foo hops into an online chatroom to ask a question then gets asked what their current Window Manager is. What?? Someone in the chat tells Foo that this is why they never use HiDPI displays, because it’s too much work to configure. What in the world, they just don’t use something because Linux doesn’t support it??

                                                                                                                                                                          Half of my own knowledge of Linux comes from having gotten things to work for Linux. I remember in the mid-2000s when I had to run wpa_supplicant by hand on my wireless adapter and then add in some custom IP routes to make it play well with my router. I learned about ALSA by trying to figure out why my audio doesn’t work on startup (turns out the device changes device IDs on boot, and configs are based on the device ID, how fun). I learned about X11 and Xorg when troubleshooting issues with resolution, compiling display drivers, setting refresh rates, HiDPI, you name it. I learned LPR and CUPS by trying to get my printers to work. For me, this stuff is fun (to an extent, I don’t exactly enjoy having to whip out xrandr when trying to get my laptop to display slides to give a presentation.) But to the average user that is somewhat interested in freedom or configurability, “owning your device” shouldn’t mean having deep expertise in computing to troubleshoot an issue.

                                                                                                                                                                          1. 2

                                                                                                                                                                            It is your device if you understand and enjoy technology to that extent, and I think this is an important point to drive home.

                                                                                                                                                                            Sure, absolutely. I was merely answering the original question from my own perspective, as requested by @kevinc. (Well, to be fair, he didn’t request it from me, but I’m presumptuous like that ;-P ).

                                                                                                                                                                            What in the world, they just don’t use something because Linux doesn’t support it??

                                                                                                                                                                            The irony! I’m posting this from a 1080p external monitor that I bought, at the time, because setting up display scaling on FreeBSD was on my TODO list.

                                                                                                                                                                            1. 1

                                                                                                                                                                              I did appreciate the bonus perspective. :)

                                                                                                                                                                          2. 3

                                                                                                                                                                            Samsung phones are a really bad example to use, since whatever-replaced-Cyanogen is still supporting the S3 last I checked (which is 11 years old at this point). Since the thing has a replaceable battery, you could reasonably expect to use it as a basic phone years to come (even if the memory is anaemic by modern Android standards).

                                                                                                                                                                            You might have slightly better luck with using Apple in your example, but they’re on a 7-8 year support cycle with OS updates too. Wait 8 years and see if you can still replace your PinePhone’s motherboard. I’d be moderately surprised if Pine64 was still making the board in that time. (I know they have a LTS A64 but I don’t know what, if any, commitments they’ve made re the phone.)

                                                                                                                                                                            1. 2

                                                                                                                                                                              Samsung phones are a really bad example to use, since whatever-replaced-Cyanogen is still supporting the S3 last I checked (which is 11 years old at this point)

                                                                                                                                                                              Yeah but Samsung isn’t. And a number of vendors whose software “supports Android” flat out refuses to run on phones with ROMs other than those approved by the manufacturer and carrier.

                                                                                                                                                                              That some enterprising open-source developers have managed to hack part of the way around the problems posed by this awful ecosystem is great, but it doesn’t diminish the problems, or most of the feelings of helplessness.

                                                                                                                                                                          3. 2

                                                                                                                                                                            Sure. Sacrificing autonomy begets dependence. Dependence begets learned helplessness, which in turn begets dependence, in a vicious cycle. Sometimes there are perfectly good reasons to sacrifice personal autonomy, such as when the needs of the many are in conflict with the needs of the one. A perfect example of that situation is Covid 19 and lockdowns + mask mandates, but that discussion isn’t relevant here. Needless to say, when I feel that some company is constraining my power to make decisions, I turn resentful. When I use an iProduct from Apple, terms and conditions apply. Terms and conditions are those things that the conquering army dictates to a surrendering foe.

                                                                                                                                                                            1. 2

                                                                                                                                                                              Thanks for elaborating! If I understand, part of the problem is the popular norm of accepting the terms and conditions rather than thinking critically about them. That would lead those who do think critically and opt out to be relatively isolated in an uphill battle. I for one am unhappy with the QWERTY keyboard standard, not there’s anything nefarious about it — it’s just something people don’t think critically about and consider alternatives to. We could have better, but we let inertia win. I don’t really have an entity to be resentful of, but I might if a corporation were behind it.

                                                                                                                                                                        1. 11

                                                                                                                                                                          The Wayland developers obviously had different goals in mind, but I think they dropped network-transparency too quickly, especially when we consider the ever-improving internet-connections that we have. In an ideal world, I could imagine sitting in the park with my laptop and transparently working on a demanding GUI-application that is running on my computer at home.

                                                                                                                                                                          Of course there’s waypipe and from what I’ve heard it works, however, transmitting buffer-state changes is very wasteful, given most GUI-applications are just simple deterministic constructs. Remote X is definitely not a shining star in regard to efficiency, either, but I imagine the following:

                                                                                                                                                                          Just like vector graphics (like SVG) can be really small compared to raster graphics, while infinite in resolution, one can imagine to have a similar approach to user interfaces (but hopefully not as bloated as SVG). In case you really need a dynamic canvas to draw on, you could do it (compared to ) at the cost of transmission size, but in most cases, you would be fine with the “vector-GUI” format.

                                                                                                                                                                          As I often like to criticize, the Wayland protocol is too “thin”. The motivation behind it was understandable, but it comes at huge costs, inconsistencies and bloat (especially in compositors and GUI-toolkit-libraries). Merely comparing to X, which is decades old, is a simple way to avoid discussing this major issue, in my opinion.

                                                                                                                                                                          1. 9

                                                                                                                                                                            This sounds like NeWS to me.

                                                                                                                                                                            1. 7

                                                                                                                                                                              I don’t totally disagree with the Wayland folks. We have a pretty good protocol for remote display with a stateful display server: the web. Particularly as so many things are using Electron and so on, proxying to the remote display at the DOM / JavaScript layer may make more sense.

                                                                                                                                                                              I’d really like to see a windowing system designed around that model. Take a minimum amount of DOM or standard statefule widgets + WebAssembly + WebGPU and so on that’s required and implement that as both a lightweight bare-metal thing and a thing that runs in a web browser. Provide a display system that runs view objects on the display server with their logic in a Wasm sandbox, a model where the display can be disconnected and reconnected, and any application can run either locally, remotely in a remote instance of the display server, and remotely in a web browser.

                                                                                                                                                                              1. 1

                                                                                                                                                                                I’m legitimately surprised no one’s tried to cut the Gordian knot with this already. You’d think Google would have gone for this.

                                                                                                                                                                              2. 2

                                                                                                                                                                                Remote X is just really simple and convenient to use, especially for the type of advanced user that has a terminal/ssh-centric workflow and wants to display individual windows. X was designed with a socket transport in the first place so using a network pipe essentially came for free. For Wayland any remote solution is and will be an afterthought. This has been a big mistake in terms of gaining acceptance because Wayland doesn’t really offer any other great practical rather than theoretical advantages. It’s supposed to be more resource efficient but was far from it when I compared by i3 setup against an equivalent one using sway.

                                                                                                                                                                                Remote X has never been great over slow networks. I find VNC to barely be usable when home working and never considered trying X. I mostly rely on ssh and vim/netrc’s ability to open files over ssh.

                                                                                                                                                                                1. 2

                                                                                                                                                                                  I’d be surprised if things like drag and drop actually work there. With X, it is kinda cool when you have two applications open on separate computers yet you can copy/paste, drag+drop, and all that between them without even thinking about it (at least not if the programs are well written).

                                                                                                                                                                                  Many remote desktop kind of things do at least some clipboard integration too, but in X it actually just works (and stuff like the Windows X server does clipboard integration with Windows programs too, but not drag and drop between them). Wayland saying “ipc belongs elsewhere” means it is unlikely to work well there either.

                                                                                                                                                                                2. 2

                                                                                                                                                                                  especially when we consider the ever-improving internet-connections that we have

                                                                                                                                                                                  Network latency hasn’t really gotten better in a long time, and I’m pretty sure that’s what’s limiting X remoting. In fact, I’m on a fairly decent DSL connection, with about 24 megabits per second download speed, and I get noticeable typing jitter when I use plain text SSH to interact with EC2 nodes. LTE was even worse, last time I tried it.

                                                                                                                                                                                  So making it smaller won’t help nearly as much as using a form-application-like model.

                                                                                                                                                                                  1. 2

                                                                                                                                                                                    So making it smaller won’t help nearly as much as using a form-application-like model.

                                                                                                                                                                                    Bring back block terminals!

                                                                                                                                                                                1. 20

                                                                                                                                                                                  Spam voters: really? What’s being sold here?

                                                                                                                                                                                  Off-topic voters: “person – Stories about particular persons”. That’s what this is. Pretty sure fellow crustaceans are people(s) too.

                                                                                                                                                                                  1. 15

                                                                                                                                                                                    Didn’t flag, but I think people who flagged for both categories aren’t happy if the person in question is the submitter, especially when there’s a lot of non-computing content.

                                                                                                                                                                                    1. 11

                                                                                                                                                                                      Cadey is a prolific blogger and self-submits every blog post she writes. IMO this isn’t an appropriate way to use a site like Lobsters, and absolutely qualifies as spam.

                                                                                                                                                                                      1. 9

                                                                                                                                                                                        I think many people flagged it as spam since the user in question (cadey) post mostly just their own blog and now this interview with themselves. Isn’t the rule of thumb that ~1/3 of your submissions should be self-promoting? Cadey’s ratio (no pun intended) far exceeds this ratio.

                                                                                                                                                                                        1. 18

                                                                                                                                                                                          I only care about the ratio of self-submissions if it’s like, content marketing or hellthreads. Pretty much all of Cadey’s content is OT and actually good, so I don’t really have a problem with it.

                                                                                                                                                                                        2. 23

                                                                                                                                                                                          Won’t speak for others, but I get a bit concerned over stuff like this that can look like building personal brand using Lobsters. The thing being sold here (mentioned in the interview obliquely) is Cadey.

                                                                                                                                                                                          The article itself isn’t very technical, and unless your brain/epistemology is wired up to support multitenancy probably not actionable.

                                                                                                                                                                                          More generally, some of us are also uncomfortable with how much the tech discourse in the social media age is being driven by Big Personalities with Quirks and characters instead of just, you know, writing code and solving problems and making interesting arguments.

                                                                                                                                                                                          Being probably a bit too real and vulnerable here:

                                                                                                                                                                                          Some of us are pretty normal in our identities, right? And maybe the ways in which we aren’t normal–at least in tech, which is currently deeply enmeshed in US-centric, white-collar, coastal, progressivism –are actively criticized and looked down upon and made to feel like liabilities more than benefits.

                                                                                                                                                                                          We get to skip the deeply unfun and personally inconvenient parts about being gender nonconforming or neurodivergent or the “wrong” minority, but we also don’t really get any celebration of our identities. That’s the tradeoff for being somewhat conformant with norms, and it gets worse the more normal you are.

                                                                                                                                                                                          The deal we were sold on in the 90s of the internet was that our ideas and the way we explain them, not our identities, mattered. But with social media and cultural shit going on right now, people seemingly don’t care about ideas so much as characters and identity.

                                                                                                                                                                                          Cadey does a lot of great Nix work, but I’d bet you ten bucks people recognize her for her fursona and Mara asides. Soatak does some solid crypto writeups, but I’d draw blanks until I’d mention “the dude with security articles that are half blue furry pictures facepalming”.

                                                                                                                                                                                          For those of use trying to get by on our technical and rhetorical chops, this is a bit hard, right? Especially when you can’t really talk about the ways you aren’t “tech normal” without getting flak.

                                                                                                                                                                                          Like, to put it really bluntly:

                                                                                                                                                                                          It is hard/intimidating enough to compete on purely technical merits with folks like Cadey, but to stand out now the market seems to incentivize other stuff.

                                                                                                                                                                                          You gotta build a blog and shill your brand. Fine.

                                                                                                                                                                                          Okay, but now you have to have high production values and a podcast mic. Fine.

                                                                                                                                                                                          Okay, but now you need a fursona, go get one commissioned. Fine.

                                                                                                                                                                                          Okay, you need a mental health issue, depression and anxiety don’t count because who doesn’t have those in late stage capitalism. Fine.

                                                                                                                                                                                          Okay, you need a minority status, and if you are “white” that will probably be most easily achieved with sexuality and gender. It’s not even enough to be gay, you’ve gotta be some flavor of queer or enby or ace or whatever–and really out about it. Trans would be awesome. Fine.

                                                                                                                                                                                          …okay, well, do you have any tulpas?

                                                                                                                                                                                          Do you see how that can make us feel? How does one even stand out at that point?

                                                                                                                                                                                          (And this is all assuming we aren’t facing the background issues of having energy to engage in online theater, overcoming imposter syndrome, dealing with economic insecurity, etc. It’s. So. Much. Worse.)

                                                                                                                                                                                          Again, to be painfully clear: this isn’t an indictment of any people that have those identities. This is an explanation for why some of us feel compelled to flag stories focusing on and celebrating the non-technical stuff.

                                                                                                                                                                                          1. 18

                                                                                                                                                                                            I’m not usually one to finger-point, but … while I sympathize with the feelings you’re expressing, what you’re saying is coming off as pretty insensitive to the experience of people with these non-norm identities.

                                                                                                                                                                                            The deal we were sold on in the 90s of the internet was that our ideas and the way we explain them, not our identities, mattered.

                                                                                                                                                                                            That was true … if you were a straight white cis male. Less true the further you diverged from that, and the less you did to hide those differences. It’s never been as bad as in a lot of other fields, but things like homophobia definitely exist in tech, and obviously also biases against women and Black people.

                                                                                                                                                                                            What I’m hearing here is kind of “it’s OK for them to be gay/trans/furry/poly/whatever, but do they have to be so blatant abou it?” But the thing is, the blatancy is frequently the kind of thing that wouldn’t stand out if it were “normal” — photos of person with partners, descriptions of hobbies, memes interspersed in posts, etc.

                                                                                                                                                                                            Do you see how that can make us feel? How does one even stand out at that point?

                                                                                                                                                                                            Furries and trans people (I’m neither, btw) get So. Much. Shit. about those things that I don’t think it’s unfair for them to get something positive out of it once in a while. I’m reminded of some friends of mine in the ‘80s and ‘90s who were so very much into Being Gay, within our social circles, that it did get a bit tiresome. Nowadays that isn’t so big a deal one way or the other. Instead we do get people being So Very Trans or So Very Furry, and I have to roll my eyes sometimes, but I think they’ve got the right because they’re having to fight to normalize what’s still very much looked down on in society.

                                                                                                                                                                                            This is an explanation for why some of us feel compelled to flag stories focusing on and celebrating the non-technical stuff.

                                                                                                                                                                                            I do agree with that, and I think this interview is edging toward being off-topic for lobsters. It’s nice to learn more about people, but I don’t think long stories about Reddit drama are relevant.

                                                                                                                                                                                            1. 19

                                                                                                                                                                                              My goal with the things I said was to talk about things that are normal to me with all of the normalcy they deserve. Stigma is hard to destigmatize if you shove it down people’s throats. I’ve been trying to be a bit more gentle about it where and when I can.

                                                                                                                                                                                              I’m reminded of some friends of mine in the ‘80s and ‘90s who were so very much into Being Gay, within our social circles, that it did get a bit tiresome.

                                                                                                                                                                                              I have some people in my friend groups that to have that “being trans is their personality” aspect to them, I find it annoying too. However that stage is usually something that people seem to adopt for a while and then really mellow out about.

                                                                                                                                                                                              Furries and trans people (I’m neither, btw) get So. Much. Shit. about those things that I don’t think it’s unfair for them to get something positive out of it once in a while. […] Instead we do get people being So Very Trans or So Very Furry, and I have to roll my eyes sometimes, but I think they’ve got the right because they’re having to fight to normalize what’s still very much looked down on in society.

                                                                                                                                                                                              This kind of stigma you’re mentioning usually leads those people to form isolated subcommunities. It can be really annoying in practice. I want to branch out and have more of a diversity of opinion in my sphere of influence, but for me to really be myself in most genuine expression I can, I have to feel safe enough to express it. There are huge chunks of my childhood and teenage years that I just literally do not remember because of that.

                                                                                                                                                                                              I really hate how much you have to “fight” this. I really wish it wouldn’t matter to people. The stigma pushes people to form isolated communities. The stigmas and cultural biases around what are really boring parts of my existence are annoying and frankly redundant in society. Things are so black and white at times that there’s nobody exploring the gray in-between. I want to make the gray palatable by treating it as normal. I want to be the most complete expression of myself as I can, and that means being honest to myself and other people about who I am.

                                                                                                                                                                                              Being openly nonbinary has almost no impact on my life. All labels are wrong (at the semiotics level we can’t really be sure that everyone has the same definition of words, see Go modules for an example of this), some labels are useful. I’ve found the nonbinary label useful because it helps me explain that space between male and female that feels “right” to me. I still present more feminine to others because that is what I am most comfortable with.

                                                                                                                                                                                              I didn’t choose the thug life, the thug life chose me.

                                                                                                                                                                                              • Tupac Shakur
                                                                                                                                                                                            2. 20

                                                                                                                                                                                              It is hard/intimidating enough to compete on purely technical merits with folks like Cadey, but to stand out now the market seems to incentivize other stuff.

                                                                                                                                                                                              You gotta build a blog and shill your brand. Fine.

                                                                                                                                                                                              Okay, but now you have to have high production values and a podcast mic. Fine.

                                                                                                                                                                                              Okay, but now you need a fursona, go get one commissioned. Fine.

                                                                                                                                                                                              Okay, you need a mental health issue, depression and anxiety don’t count because who doesn’t have those in late stage capitalism. Fine.

                                                                                                                                                                                              Okay, you need a minority status, and if you are “white” that will probably be most easily achieved with sexuality and gender. It’s not even enough to be gay, you’ve gotta be some flavor of queer or enby or ace or whatever–and really out about it. Trans would be awesome. Fine.

                                                                                                                                                                                              …okay, well, do you have any tulpas?

                                                                                                                                                                                              I’m sorry? That doesn’t describe me, or Dan Luu, or Amos, or Chris Siebenmann, or Julia Evans, or @matklad, or @DanielBMarkham, or Daniel Lemire, all of whom regularly top-story on lobsters.

                                                                                                                                                                                              Do you see how that can make us feel? How does one even stand out at that point?

                                                                                                                                                                                              I don’t think this is describing you, because the last thing you authored here was two years ago. And to be clear, this is fine: people shouldn’t have to Generate Discourse to be respected and considered authorities in their community. But it suggests to me that you’re not representing your actual feelings in your argument here.

                                                                                                                                                                                              1. 11

                                                                                                                                                                                                As somebody once said on this site:

                                                                                                                                                                                                I don’t think that you can fundamentally ensure that people always feel welcome, and there is no surer road to ruin than to cater to everybody’s exclusionary preferences. Everybody has a reason to hate Nazis, or furries, or Republicans, or women, or whatever–the only way a community grows and flourishes is by providing people the space and protocols to interact without requiring alignment on those things.

                                                                                                                                                                                                If you can’t even be a decent person by your own standards, then why should anybody listen to your moralizing?

                                                                                                                                                                                                1. 9

                                                                                                                                                                                                  Hey there, I’m the guy behind opguides.info. I appreciate hearing this view and understand where you’re coming from, but I also fully disagree with it. Just as I didn’t take any of your reply personally, please dont take this personally either:

                                                                                                                                                                                                  The article itself isn’t very technical

                                                                                                                                                                                                  I’m a bit confused right of the bat here, the entire thing seems pretty technical-focused to me. It’s technical in the low-level explaining how to do this cool thing with cool new language sense, but the questions are almost all focused on directly technical content, the way we live/work in a digital world, and lessons learned in the wold of tech. Not sure what more ‘technical’ content you could want in an interview

                                                                                                                                                                                                  The deal we were sold on in the 90s of the internet was that our ideas and the way we explain them, not our identities

                                                                                                                                                                                                  I was born in ‘98. I was never sold that deal, nor is it one that I would accept. I don’t love the fact that today everything is about how big your name is and that actors run for office just to up their fame. On the other hand, if we go entirely your way of ideas > identity, we wind up in a situation where people can’t use their knowledge and skills to defend their other interests as legitimate. Imagine a black professor being denied a position and it going to a less-qualified white person, their skills legitimize their position. Showing the public that you can be LGBT+ and valuable, it legitimizes being LGBT+.

                                                                                                                                                                                                  we also don’t really get any celebration of our identities. That’s the tradeoff for being somewhat conformant with norms, and it gets worse the more normal you are.

                                                                                                                                                                                                  Being ‘normal’ is a choice. I’m bi, that’s not a choice, but other than some unfriendly folks ™ in highschool that broke my nose for it, it really hasn’t affected me. On the other hand, I chose to be a furry, it gives me something weird and fun to celebrate. You’re welcome to join the community. If you’re unhappy that you’re normal, you’re unhappy because of a choice. Find something different to enjoy, be it being a furry, being overly into model trains, whatever. If you’re truly passionate about something, it’s probably weird.

                                                                                                                                                                                                  Cadey does a lot of great Nix work, but I’d bet you ten bucks people recognize her for her fursona and Mara asides. Soatak does some solid crypto writeups, but I’d draw blanks until I’d mention “the dude with security articles that are half blue furry pictures facepalming”.

                                                                                                                                                                                                  Yeah, and? Should they just not put that on their posts? It’s their site, their content, which they’re taking the time to write and release for free, often at cost of hosting it. Sure, that cost may be offset by finding employers or other benefits, but ultimately they’re adding their personal touch because it’s their personal site. Just as I do on my site, as I would hope anybody would on their site. If you want a lack of personality, your best bet is to read straight-up research papers and academic journals.

                                                                                                                                                                                                  For those of use trying to get by on our technical and rhetorical chops, this is a bit hard, right?

                                                                                                                                                                                                  Not really? The reason people like our (Casey, Soatok, other furries + ) content is because we know how to make a bit of a show out of it and make it fun to read. You don’t need to be ‘weird’ to make it fun to read, you just have to know how to put on a bit of a show. Take http://www.jezzamon.com/fourier/ for example or any of the videos from the big educational YouTube channels. I think TomScott is a great example of this, from what I can tell he’s a pretty average dude.

                                                                                                                                                                                                  It is hard/intimidating enough to compete on purely technical merits with folks like Cadey, but to stand out now the market seems to incentivize other stuff.

                                                                                                                                                                                                  Yeah, the market will never incentivize the purely technical because in general, it’s super dry to read. It’s very hard to stand out and get public attention on something written for a strictly technical audience with no pizaz. It’s why CVE’s with name’s like HeartBleed make the news.

                                                                                                                                                                                                  Okay, but now you have to have high production values and a podcast mic. Fine. Okay, but now you need a fursona, go get one commissioned. Fine.

                                                                                                                                                                                                  Okay, really? Look at how many views early Kahn acadaemy videos still get despite the audio quality being roughly equivilent to being recorded though a tin can. Look at how many devs have very successful public presences without a fursona (Foone comes to mind).

                                                                                                                                                                                                  Okay, you need a mental health issue, depression and anxiety don’t count because who doesn’t have those in late stage capitalism. Fine.

                                                                                                                                                                                                  I’m neurotypical. I’m not depressed. I’m not anxious. I go by a different name than the one I was given legally and I have a fursona, but otherwise I’m normal. I don’t take any meds to make my brain work right. Regardless, I think this is one of the most redicious things I’ve read in a long time and I’m honestly annoyed that I’m even taking the time to dignify it with a response.

                                                                                                                                                                                                  How does one even stand out at that point?

                                                                                                                                                                                                  By making something cool that other people enjoy. You want things to be rewarded for their technical merrit? then make something technically cool, like https://github.com/hundredrabbits/Orca or https://library.vcvrack.com/?query=&brand=Aria+Salvatrice&tag=&license= . Let your work be what stands out. Make good art or good music.

                                                                                                                                                                                                  In conclusion: This is technical writing. If you’re not happy with your own technical writing or projects it’s not an excuse to take down others. Thanks, have a nice day ^-^.

                                                                                                                                                                                                  1. 8

                                                                                                                                                                                                    (And this is all assuming we aren’t facing the background issues of having energy to engage in online theater, overcoming imposter syndrome, dealing with economic insecurity, etc. It’s. So. Much. Worse.)

                                                                                                                                                                                                    And for minorities those things are already much worse. What’s wrong with people building a brand to get a job they might not otherwise? It’s already hard enough for minorities and women to get work in tech so who can blame them for trying to get a leg up?

                                                                                                                                                                                                    Not to mention being a visible minority or woman can help others in those groups not feel like an impostor. When cishet white dude is the assumed default, which it very much is in tech, not mentioning it makes people assume that you’re that too. So when you look around at who’s in the field and you’re a minority it can feel like you’re the only one.

                                                                                                                                                                                                    Then there’s that fact that people being so open and honest about these things can help improve everyone else’s experience in the industry. People like to hire people who are like them because that’s what’s familiar to them. So when a non-binary person walks through the door what do you think is going to happen? If they’ve never met or seen a non-binary person before what are the chances that they’ll hire them? Now what are the chances if they’ve read a bunch of technical posts by a different non-binary person who’s very open and proud about it?

                                                                                                                                                                                                    The deal we were sold on in the 90s of the internet was that our ideas and the way we explain them, not our identities, mattered. But with social media and cultural shit going on right now, people seemingly don’t care about ideas so much as characters and identity.

                                                                                                                                                                                                    You can sit here and complain that everything isn’t about technical merit or whatever any more but it never has been. Who had access to computers in the 90s? I can’t imagine it was many black trans women. All that’s happened is tha the internet has gotten more ubiquitous and different people have gotten on it and made it their home.

                                                                                                                                                                                                    Do you see how that can make us feel? How does one even stand out at that point?

                                                                                                                                                                                                    I’m going to be blunt here. Who the fuck cares? You’ve described someone who’s the assumed default in the industry. Someone who doesn’t have to worry about systemic discrimination. Why the fuck would I care if you suddenly feel like you’re not special any more? Because that’s what this reads like. “I’m no longer special just for being able to program well.”

                                                                                                                                                                                                    If other minorities and women being open about being those things makes you uncomfortable then good, feel uncomfortable because now you’ll know a sliver of what most of use feel on a daily basis.

                                                                                                                                                                                                    1. 7

                                                                                                                                                                                                      …we also don’t really get any celebration of our identities. That’s the tradeoff for being somewhat conformant with norms, and it gets worse the more normal you are.

                                                                                                                                                                                                      As someone who’s from a mainstream but geek-culture-leaning background, then also queer and out and of a political scapegoat group, then also married to the opposite sex and gaining enough job responsibilities that I can’t engage in every fight, then also tired of Internet culture battles but sympathetic to their participants, I’ll offer some perspective and I hope you find it useful.

                                                                                                                                                                                                      Everybody has some collection of qualities that, in the aggregate, do make each of them unique, and probably very far from a mainstream preconception. Today, talent departments in tech value that very thing. Each of those qualities may or may not have a “____ in tech” group you can join, or be thought to matter at all. But in the current era of people hiring for Culture Add instead of Culture Fit, you surely have something unique to contribute. Suppose you care a lot about your flower garden: You don’t have to leverage that for the sake of a personal brand or just for an interview process, but I believe you could if you want to. For those who have been marginalized out of job consideration in the past, the rising valuation of Culture Add / inclusion / diversity represents an opportunity they didn’t have previously. It doesn’t have to cost you, if you’re willing to bring your background and your nature to the table. Your perspective is viewed as an advantage to the group to the degree that it broadens the range of perspectives available to learn from. It’s not that two identical people are a liability, it’s that a kitchen benefits less from a tenth nonstick pan than the first spatula.

                                                                                                                                                                                                      I’ve used the problem domain of getting hired in tech as an example, but this could apply to other domains of life. I realize it’s probably about as frustrating as being told to “just be yourself” on a date in your twenties.

                                                                                                                                                                                                      1. 6

                                                                                                                                                                                                        This is an explanation for why some of us feel compelled to flag stories focusing on and celebrating the non-technical stuff.

                                                                                                                                                                                                        Nothing you wrote here meets the criteria for any flag.

                                                                                                                                                                                                        1. 6

                                                                                                                                                                                                          Thanks for your response. One thing other replies haven’t mentioned:

                                                                                                                                                                                                          unless your brain/epistemology is wired up to support multitenancy probably not actionable.

                                                                                                                                                                                                          ~70% of what I read on Lobsters is non-actionable, and I’m better (on various axes) for having read it.

                                                                                                                                                                                                          Also, I once thought the same as you, but ~18 months ago I changed that after talking to (none other than) Cadey.

                                                                                                                                                                                                          (Further, your angersock/friendlysock duality has more in common with some plural approaches than you might’ve guessed.)

                                                                                                                                                                                                          I’d add ..

                                                                                                                                                                                                          Anyone can form a personal identity that’s worth celebrating. You don’t need anyone’s permission. You don’t need to feign interest (or non-interest) in particular genders or whatever, don’t need to go become a monk or create a bunny girl tulpa or whatever. The point of identity is that it’s something special about you.

                                                                                                                                                                                                          Maybe that seems a bit trite when you see an unspecified mass of people who all call themselves trans, because, perhaps to the relatively ‘normal’ outsider, it looks like people who are differentiating themselves by all adopting the same relatively un-differentiated label/stance/whatever. I can only really say that it’s really not that — literally every trans person has a journey and mindset that is, for the most part, radically different to others. It’s the same with other labels you’ve mentioned.

                                                                                                                                                                                                          No-one’s saying you go need to amass a series of descriptors, because frankly, that’s not what most of us have set out to do. We’ve arrived here by our own ways, and wherever you are, you’ve gotten there by your own way too. I don’t think you’re lesser because the collection of labels that happen to describe you might be more prevalent in the population. I do note it makes it harder to differentiate yourself, and that that makes the notion of having to differentiate yourself less appealing — you are on the back foot when it comes to differentiating yourself. I’m not looking to deny that that has its own difficulties.

                                                                                                                                                                                                          (I don’t think it’s worth trying to compare those difficulties to, say, the difficulties trans or plural or ace or whatever people face, because they’re just in different ballparks entirely. I don’t see you here as actually trying to say “well you were thrown out of home but someone once called me average”, even if it would make my line of thought easier to limn. I’m also not sure I accept the idea that, as a trans person, other people should roll their eyes at what I say but then hold their tongue because I have the right ..? No flak intended to snej, sincerely, but I’d tell a close friend acting that way to fuck off and be straight with me.)

                                                                                                                                                                                                          I don’t think that means the solution is to say that we should level the playing field by discouraging people leaning on their unique points of view. If someone occupies a position that gives them insights not commonly held, then that is of interest to me — regardless of how widely applicable they might be. As I said, most of what I read isn’t actionable or applicable to me, but it often surprises me the things that do end up being so.

                                                                                                                                                                                                          I think the solution is for those who feel like they have nothing to add to find what they have to add. No-one came down from the light* and gifted me my fursona/alter/whatever. I felt myself out, spent years (decades) on it, and hey, there she is, right in my Gravatar. If people think that adds personality, then great. If people think it’s worth spamming the comments with vaguely anti-furry rhetoric, then welp. It’s a decision I’ve made and it’s time I’ve invested, and not everyone will see it the same way. I didn’t decide to be a special snowflake, but I did decide that my identity was a place where I wanted to make life interesting. As a result, I have some experiences that are unique, and sometimes I’d like to share those. It doesn’t devalue the experiences of others without. Attention may be a scarce resource, but upvotes are not.

                                                                                                                                                                                                          Here’s the kicker: there’s only so much to the “[identity] intersecting with tech” discourse to be added to. When I blog about stuff I don’t mix in my perspectives as a trans person because I don’t feel like I have anything to add. Like, if I posted a post a week for three weeks on MIPS I load delay slots, some people would probably find it of at least historical interest. If I continued apace for three years, eventually it’d get pretty solidly downvoted because jesus christ Ashe give it up, there’s only so much to be said.

                                                                                                                                                                                                          But if you ask me, this interview covers a lot of aspects that have had very little coverage. These are interesting points of personality and identity, and they interact with Cadey’s technical work in a way that makes them clearly on-topic.

                                                                                                                                                                                                          I get that one could read this and feel left out. But don’t flag as off-topic because you can’t put yourself in their shoes. I feel absolutely certain living in your shoes has its own unique points of interest—even if they don’t occupy as “easily” a recognised category as gender identity or whatever. Ones that I’d be unable to relate to. I’d like to hear about them.

                                                                                                                                                                                                          1. 3

                                                                                                                                                                                                            Same question as last time:

                                                                                                                                                                                                            If this isn’t an appropriate use of the “person” flag, then what is, and how is it different?

                                                                                                                                                                                                            1. 9

                                                                                                                                                                                                              I generally like person for people who are dead or no longer in the field, usually with the historical tag.

                                                                                                                                                                                                        1. 18

                                                                                                                                                                                                          I’ve marked this as off topic as about half of the article is a rant about reddit moderation (?) which is not really computing-related.

                                                                                                                                                                                                          1. 23

                                                                                                                                                                                                            I’m not sure what the point is of even having the “culture” tag, if this post is off-topic for the site. How does this not count?

                                                                                                                                                                                                            1. 7

                                                                                                                                                                                                              Can you find me another culture tagged submission that’s about the mods of a subreddit being assholes? Most of the recent ones I’ve seen are about computing.

                                                                                                                                                                                                              1. 22

                                                                                                                                                                                                                No, but neither is the thing I wrote about the mods of a subreddit being assholes. It’s about toxic gatekeeping in the tech community.

                                                                                                                                                                                                                1. 4

                                                                                                                                                                                                                  It’s not about these mods in particular but moreso the fact that a place like r/netsec could be like this, and this is used as a starting point to have the reader think about technical gatekeeping issues as a whole. Correct me if I’m wrong though @soatok.

                                                                                                                                                                                                              2. 6

                                                                                                                                                                                                                Oh, sweet irony…

                                                                                                                                                                                                                1. 6

                                                                                                                                                                                                                  aha, I see what you mean, but (as stated in the post) gatekeeping is important to most communities to maintain quality. r/askhistory may “gatekeep” bad history takes, but it makes the sub so much better for it.

                                                                                                                                                                                                                  1. 1

                                                                                                                                                                                                                    It depends on active definitions. In recent years, people seem to critically invoke “gatekeeping” in order to describe needlessly controlling access to a social system based on some sort of arbitrary social measure. That’s the definition used in this post as far as I can tell.

                                                                                                                                                                                                                    So filtering out ahistorical takes from a history forum is not something I’d personally be reaching for “gatekeeping” to describe. And I think that mixing up good-faith content moderation with bad-faith social gatekeeping does harm to both definitions. That is for example, unless the moderator were to post a rude comment attributing the quality of the post to a perceived lack of a college degree. Then that would be gatekeeping. Definitions are fluid though, and the use and connotations of this word have changed over time.

                                                                                                                                                                                                                    1. 7

                                                                                                                                                                                                                      Restricting access is categorically gatekeeping.

                                                                                                                                                                                                                      I chose to contrast this with toxic gatekeeping (two word noun), and describe how gatekeeping can become toxic gatekeeping, rather than e.g. narrowly define gatekeeping for the purposes of the blog post.

                                                                                                                                                                                                                      1. 2

                                                                                                                                                                                                                        This might be one of those rare times more words is better. Something like “the specific kind of gatekeeping that becomes toxic.” A lot of people seem to have trouble parsing phrases without considering each word independently, especially when it comes to identity and interests.

                                                                                                                                                                                                              1. 6

                                                                                                                                                                                                                “Ad Hoc Documentation” is also different from “Real Documentation” because it’s situational. I don’t have to write to whoever doing whatever. I’m writing for cgenschwap and they’re trying to make the authored-by flag work. That makes the problem you’re solving fundamentally different, and I think that has as much to do with it as graphs-vs-trees does.

                                                                                                                                                                                                                I hate writing documentation because I never no how much to write down. Too much, and it becomes an incomprehensible deluge. Not enough, and it’s useless.

                                                                                                                                                                                                                1. 3

                                                                                                                                                                                                                  You’re right, ad-hoc documentation can be situational. However I’ve found many cases to be of the form “Oh, X happens all the time with Y, just do A, B and C to resolve it.” While this is ad-hoc, it can and should exist as a how-to or runbook in the documentation – its a known situation with a known resolution. There are definitely situations where it is highly specific, but I think those are fairly rare (for instance, that information can always go into a “Troubleshooting” section).

                                                                                                                                                                                                                1. 45

                                                                                                                                                                                                                  FWIW, this is how you express conditional arguments / struct fields in Rust. The condition has to encompass the name as well as the type, not just the type as was first attempted.

                                                                                                                                                                                                                  I feel like Rust has definitely obliterated its complexity budget in unfortunate ways. Every day somebody comes to the sled discord chat with confusion over some async interaction. The fixation on async-await, despite it slowing down almost every real-world workload it is applied to, and despite it adding additional bug classes and compiler errors that simply don’t exist unless you start using it, has been particularly detrimental to the ecosystem. Sure, the async ecosystem is a “thriving subcommunity” but it’s thriving in the Kuhnian sense where a field must be sufficiently problematic to warrant collaboration. There’s no if-statement community anymore because they tend to work and be reasonably well understood. With async-await, I observed that the problematic space of the overall community shifted a bit from addressing external issues through memory safety bug class mitigation to generally coping with internal issues encountered due to some future not executing as assumed.

                                                                                                                                                                                                                  The problematic space of a community is a nice lens to think about in general. It is always in-flux with the shifting userbase and their goals. What do people talk about? What are people using it for? As the problematic space shifts, at best it can introduce the community to new ideas, but there’s also always an aspect of it that causes mourning over what it once represented. Most of my friends who I’ve met through Rust have taken steps to cut interactions with “the Rust community” down to an absolute minimum due to it tending to produce a feeling of alienation over time. I think this is pretty normal.

                                                                                                                                                                                                                  I’m going to keep using Rust to build my database in and other things that need to go very fast, but I see communities like Zig’s as being in some ways more aligned with the problematic spaces I enjoy geeking out with in conversations. I’m also thinking about getting a lot more involved in Erlang since I realized I haven’t felt that kind of problem space overlap in any language community since I stopped using it.

                                                                                                                                                                                                                  1. 31

                                                                                                                                                                                                                    I was surprised to see the Rust community jump on the async-await bandwagon, because it was clear from the beginning it’s a bandwagon. When building a stable platform (e.g. a language) you wait for the current fashion to crest and fall, so you can hear the other side of the story – the people who used it in anger, and discovered what the strengths and weaknesses really are. Rust unwisely didn’t do that.

                                                                                                                                                                                                                    I will note though that the weaknesses of the async-await model were apparent right from the beginning, and yet here we are. A lesson for future languages.

                                                                                                                                                                                                                    1. 28

                                                                                                                                                                                                                      This hits me particularly hard because I had experienced a lot of nearly-identical pain around async when using various flavors of Scala futures for a few years before picking up Rust in 2014. I went to the very first Rust conference, Rust Camp in 2015 at Berkeley, and described a lot of the pain points that had caused significant issues in the Scala community to several of the people directly working on the core async functionality in Rust. Over the years I’ve had lots of personal conversations with many of the people involved, hoping that sharing my experiences would somehow encourage others to avoid well-known painful paths. This overall experience has caused me to learn a lot about human psychology - especially our inability to avoid problems when there are positive social feedback loops that lead to those problems. It makes me really pessimistic about climate apocalypse and rising authoritarianism leading us to war and genocides, and the importance of taking months and years away from work to enjoy life for as long as it is possible to do so.

                                                                                                                                                                                                                      The content of ideas does not matter very much compared to the incredibly powerful drive to exist in a tribe. Later on when I read Kuhn’s Structure of Scientific Revolutions, Feyerabend’s Against Method, and Ian Hacking’s Representing and Intervening, which are ostensibly about the social aspects of science, I was blown away by how strongly their explanations of how science often moves in strange directions that may not actually cause “progress” mapped directly to the experiences I’ve had while watching Rust grow and fail to avoid obvious traps due to the naysayers being drowned out by eager participants in the social process of Making Rust.

                                                                                                                                                                                                                      1. 7

                                                                                                                                                                                                                        Reminds me of the theory that Haskell and Scala appeal because they’re a way for the programmer to needsnipe themselves

                                                                                                                                                                                                                        1. 5

                                                                                                                                                                                                                          Thanks for fighting the good fight. Just say “no” to complexity.

                                                                                                                                                                                                                          Which of those three books you mentioned do you think is most worthwhile?

                                                                                                                                                                                                                          1. 10

                                                                                                                                                                                                                            I think that Kuhn’s Structure of Scientific Revolutions has the broadest appeal and I think that nearly anyone who has any interaction with open source software will find a tremendous number of connections to their own work. Science’s progressions are described in a way that applies equally to social-technical communities of all kinds. Kuhn is also the most heavily cited thinker in later books on the subject, so by reading his book, you gain deeper access to much of the content of the others, as it is often assumed that you have some familiarity with Kuhn.

                                                                                                                                                                                                                            You can more or less replace any mention of “paper citation” with “software dependency” without much loss in generality while reading Kuhn. Hacking and Feyerabend are more challenging, but I would recommend them both highly. Feyerabend is a bit more radical and critical, and Hacking zooms out a bit more and talks about a variety of viewpoints, including many perspectives on Kuhn and Feyerabend. Hacking’s writing style is really worth experiencing, even by just skimming something random by him, by anyone who writes about deep subjects. I find his writing to be enviably clear, although sometimes he leans a bit into sarcasm in a way that I’ve been put off by.

                                                                                                                                                                                                                          2. 4

                                                                                                                                                                                                                            If you don’t mind, what’s an example of async/await pain that’s common among languages and not to do with how Rust uniquely works? I ask because I’ve had a good time with async/await, but in plainer, application-level languages.

                                                                                                                                                                                                                            (Ed: thanks for the thoughtful replies)

                                                                                                                                                                                                                            1. 12

                                                                                                                                                                                                                              The classic “what color is your function” blog post describes what is, I think, such a pain? You have to choose in your API whether a function can block or not, and it doesn’t compose well.

                                                                                                                                                                                                                              1. 3

                                                                                                                                                                                                                                I read that one, and I took their point. All this tends to make me wonder if Swift (roughly, Rust minus borrow checker plus Apple backing) is doing the right thing by working on async/await now.

                                                                                                                                                                                                                                But so far I don’t mind function coloring as I use it daily in TypeScript. In my experience, functions that need to be async tend to be the most major steps of work. The incoming network request is async, the API call it makes is async, and then all subsequent parsing and page rendering aren’t async, but can be if I like.

                                                                                                                                                                                                                                Maybe, like another commenter said, whether async/await is a net positive has more to do with adapting the language to a domain that isn’t otherwise its strong suit.

                                                                                                                                                                                                                                1. 16

                                                                                                                                                                                                                                  You might be interested in knowing that Zig has async/await but there is no function coloring problem.

                                                                                                                                                                                                                                  https://kristoff.it/blog/zig-colorblind-async-await/

                                                                                                                                                                                                                                  1. 3

                                                                                                                                                                                                                                    Indeed this is an interesting difference at least in presentation. Usually, async/await provides sugar for an existing concurrency type like Promise or Task. It doesn’t provide the concurrency in the first place. Function colors are then a tradeoff for hiding the type, letting you think about the task and read it just like plain synchronous code. You retain the option to call without await, such that colors are not totally restrictive, and sometimes you want to use the type by hand; think Promise.all([…]).

                                                                                                                                                                                                                                    Zig seems like it might provide all these same benefits by another method, but it’s hard to tell without trying it. I also can’t tell yet if the async frame type is sugared in by the call, or by the function definition. It seems like it’s a sort of generic, where the nature of the call will specialize it all the way down. If so, neat!

                                                                                                                                                                                                                                    1. 7

                                                                                                                                                                                                                                      It seems like it’s a sort of generic, where the nature of the call will specialize it all the way down. If so, neat!

                                                                                                                                                                                                                                      That’s precisely it!

                                                                                                                                                                                                                                      1. 2

                                                                                                                                                                                                                                        I’ve been poking at Zig a bit since this thread; thank you for stirring my interest. :)

                                                                                                                                                                                                                              2. 6

                                                                                                                                                                                                                                Well, I think that async/await was a great thing for javascript, and generally it seems to work well in languages that have poor threading support. But Rust has great threading support, and Rust’s future-based strategy aimed from the beginning at copying Scala’s approach. A few loud research-oriented voices in the Rust community said “we think Scala’s approach looks great” and it drowned out the chorus of non-academic users of Scala who had spent years of dealing with frustrating compilation issues and issues where different future implementations were incompatible with each other and overall lots of tribalism that ended up repeating in a similar way in the Rust async/await timeline.

                                                                                                                                                                                                                                1. 5

                                                                                                                                                                                                                                  I am somewhat surprised that you say Rust’s futures are modeled after Scala’s. I assume the ones that ended up in the standard library. As for commonalities: They also offer combinators on top of a common futures trait and you need explicit support in libraries - that’s pretty much all that is similar to Rust’s.

                                                                                                                                                                                                                                  In Scala, futures were annoying because exceptions and meaningless stacktraces. In Rust, you get the right stacktraces and error propagation.

                                                                                                                                                                                                                                  In Rust, Futures sucked for me due to error conversions and borrowing being basically unsupported until async await. Now they are still annoying because of ecosystem split (sync vs various partially compatible async).

                                                                                                                                                                                                                                  The mentioned problem of competing libraries is basically unpreventable in fields without wide consensus and would have happened with ANY future alternative. If you get humans to agree on sensible solutions and not fight about irrelevant details, you are a wizard.

                                                                                                                                                                                                                                  Where I agree is that it was super risky to spend language complexity budget on async/await, even though solving the underlying generator/state machine problem felt like a good priority. While async await feels a bit to special-cased and hacky to be part of the language… It could be worse. If we find a better solution for async in Rust, we wouldn’t have to teach the current way anymore.

                                                                                                                                                                                                                                  Other solutions would just have different pros and cons. E.g. go’s or zig’s approach seemed the solution even deeper into the language with the pro of setting a somewhat universal standard for the language.

                                                                                                                                                                                                                                  1. 3

                                                                                                                                                                                                                                    It was emulating Finagle from the beginning: https://medium.com/@carllerche/announcing-tokio-df6bb4ddb34 but then the decision to push so much additional complexity into the language itself so that people could have an easier time writing strictly worse systems was just baffling.

                                                                                                                                                                                                                                    Having worked in Finagle for a few years before that, I tried to encourage some of the folks to aim for something lighter weight since the subset of Finagle users who felt happy about its high complexity seemed to be the ones who went to work at Twitter where the complexity was justified, but it seemed like most of the community was pretty relieved to switch to Akka which didn’t cause so much type noise once it was available.

                                                                                                                                                                                                                                    I don’t expect humans not to fragment now, but over time I’ve learned that it’s a much more irrational process than I had maybe believed in 2014. Mostly I’ve been disappointed about being unable to communicate with what was a tiny community about something that I felt like I had a lot of experience with and could help other people avoid pain around, but nevertheless watch it bloom into a huge crappy thing that now comes back into my life every day even when I try to ignore it by just using a different feature set in my own stuff.

                                                                                                                                                                                                                                2. 3

                                                                                                                                                                                                                                  I hope you will get a reply by someone with more Rust experience than me, but I imagine that the primary problem is that even if you don’t have to manually free memory in Rust, you still have to think about where the memory comes from, which tends to make lifetime management more complicated, requiring to occasionally forcefully move things unto the heap (Box) and also use identity semantics (Pin), and so all of this contributes to having to deal with a lot of additional complexity to bake into the application the extra dynamicism that async/await enables, while still maintaining the safety assurances of the borrow checker.

                                                                                                                                                                                                                                  Normally, in higher level languages you don’t ever get to decide where the memory comes from, so this is a design dimension that you never get to explore.

                                                                                                                                                                                                                                3. 2

                                                                                                                                                                                                                                  I’m curious if you stuck around in Scala or pay attention to what’s going on now because I think it has one of the best stories when it comes to managing concurrency. Zio, Cats Effect, Monix, fs2 and Akka all have different goals and trade offs but the old problem of Future is easily avoided

                                                                                                                                                                                                                                4. 6

                                                                                                                                                                                                                                  I was surprised to see the Rust community jump on the async-await bandwagon, because it was clear from the beginning it’s a bandwagon.

                                                                                                                                                                                                                                  I’m not surprised. I don’t know how async/await works exactly, but it definitely has a clear use case. I once implemented a 3-way handshake in C. There was some crypto underneath, but the idea was, from the server’s point of view was to receive a first message, respond, then wait for the reply. Once the reply comes and is validated the handshake is complete. (The crypto details were handled by a library.)

                                                                                                                                                                                                                                  Even that simple handshake was a pain in the butt to handle in C. Every time the server gets a new message, it needs to either spawn a new state machine, or dispatch it to an existing one. Then the state machine can do something, suspend, and wait for a new message. Note that it can go on after the handshake, as part of normal network communication.

                                                                                                                                                                                                                                  That state machine business is cumbersome and error prone, I don’t want to deal with it. The programming model I want is blocking I/O with threads. The efficiency model I want is async I/O. So having a language construct that easily lets me suspend & resume execution at will is very enticing, and I would jump to anything that gives me that —at least until I know better, which I currently don’t.

                                                                                                                                                                                                                                  I’d even go further: given the performance of our machines (high latencies and high throughputs), I believe non-blocking I/O at every level is the only reasonable way forward. Not just for networking, but for disk I/O, filling graphics card buffers, everything. Language support for this is becoming as critical as generics themselves. We laughed “lol no generics” at Go, but now I do believe it is time to start laughing “lol no async I/O” as well. The problem now is to figure out how to do it. Current solutions don’t seem to be perfect (though there may be one I’m not aware of).

                                                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                                                    The whole thing with async I/O is that process creation is too slow, and then thread creation was too slow, and some might even consider coroutine creation too slow [1]. It appears that concerns that formerly were of the kernel (managing I/O among tasks; scheduling tasks) are now being pushed out to userland. Is this the direction we really want to go?

                                                                                                                                                                                                                                    [1] I use coroutines in Lua to manage async I/O and I think it’s fine. It makes the code look like non-blocking, but it’s not.

                                                                                                                                                                                                                                    1. 2

                                                                                                                                                                                                                                      I don’t think it’s unreasonable to think that the kernel should have as few concerns as possible. It’s a singleton, it doesn’t run with the benefit of memory protection, and its internal APIs aren’t as stable as the ones it provides to userland.

                                                                                                                                                                                                                                      … and, yes, I think a lot of async/await work is LARPing. But that’s because a lot of benchmark-oriented development is LARPing, and probably isn’t special to async/await specifically.

                                                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                                                        I’m not sure what you’re getting at. I want async I/O to avoid process creation and thread creation and context switches, and even scheduling to some extent. What I want is one thread per core, and short tasks being sent to them. No process creation, no thread creation, no context switching. Just jump the instruction pointer to the relevant task, and return to the caller when it’s done.

                                                                                                                                                                                                                                        And when the task needs to, say, read from the disk, then it should do so asynchronously: suspend execution, return to the caller, wait for the response to come back, and when it does resume execution. It can be done explicitly with message passing, but that’s excruciating. A programming model where I can kinda pretend the call is blocking (but in fact we’re yielding to the caller) is much nicer, and I believe very fast.

                                                                                                                                                                                                                                    2. 5

                                                                                                                                                                                                                                      Agreed. I always told people that async/await will be just as popular as Java’s synchronized a few years down the road. Some were surprised, some were offended, but sometimes reality is uncomfortable.

                                                                                                                                                                                                                                    3. 29

                                                                                                                                                                                                                                      Thank you for sharing, Zig has been much more conservative than Rust in terms of complexity but we too have splurged a good chunk of the budget on async/await. Based on my experience producing introductory materials for Zig, async/await is by far the hardest thing to explain and probably is going to be my biggest challenge to tackle for 2021. (that said, it’s continuations, these things are confusing by nature)

                                                                                                                                                                                                                                      On the upside

                                                                                                                                                                                                                                      despite it slowing down almost every real-world workload it is applied to

                                                                                                                                                                                                                                      This is hopefully not going to be a problem in our case. Part of the complexity of async/await in Zig is that a single library implementation can be used in both blocking and evented mode, so in the end it should never be the case that you can only find an async version of a client library, assuming authors are willing to do the work, but even if not, support can be added incrementally by contributors interested in having their use case supported.

                                                                                                                                                                                                                                      1. 17

                                                                                                                                                                                                                                        I feel like Rust has definitely obliterated its complexity budget in unfortunate ways.

                                                                                                                                                                                                                                        I remember the time I asked one of the more well-known Rust proponents “so you think adding features improves a language” and he said “yes”. So it was pretty clear to me early on that Rust would join the feature death march of C++, C#, …

                                                                                                                                                                                                                                        Rust has many language features and they’re all largely disjoint from each other, so knowing some doesn’t help me guess the others.

                                                                                                                                                                                                                                        That’s so painfully true.

                                                                                                                                                                                                                                        For instance, it has different syntax for struct creation and function calls, their poor syntax choices also mean that structs/functions won’t get default values any time soon.

                                                                                                                                                                                                                                        ; is mandatory (what is this, 1980?), but you can leave out , at the end.

                                                                                                                                                                                                                                        The severe design mistake of using <> for generics also means you have to learn 4 different syntax variations, and when to use them.

                                                                                                                                                                                                                                        The whole module stuff is way too complex and only makes sense if you programmed in C before. I have basically given up on getting to know the intricacies, and just let IntelliJ handle uses.

                                                                                                                                                                                                                                        Super weird that both if and switch exist.

                                                                                                                                                                                                                                        Most of my friends who I’ve met through Rust have taken steps to cut interactions with “the Rust community” down to an absolute minimum due to it tending to produce a feeling of alienation over time.

                                                                                                                                                                                                                                        Yes, that’s my experience too. I have some (rather popular) projects on GitHub that I archive from time to time to not having to deal with Rust people. There are some incredibly toxic ones, which seem to be – for whatever reason – close to some “core” Rust people, so they can do whatever the hell they like.

                                                                                                                                                                                                                                        1. 6

                                                                                                                                                                                                                                          For instance, it has different syntax for struct creation and function calls

                                                                                                                                                                                                                                          Perhaps they are trying to avoid the C++ thing where you can’t tell whether foo(bar) is struct creation or a function call without knowing what foo is?

                                                                                                                                                                                                                                          The whole module stuff is way too complex and only makes sense if you programmed in C before. I have basically given up on getting to know the intricacies, and just let IntelliJ handle uses.

                                                                                                                                                                                                                                          It only makes sense to someone who has programmed in C++. C’s “module” system is far simpler and easier to grok.

                                                                                                                                                                                                                                          Super weird that both if and switch exist.

                                                                                                                                                                                                                                          Would you have preferred

                                                                                                                                                                                                                                          match condition() {
                                                                                                                                                                                                                                              true => {
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                              false => {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                              },
                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                          I think that syntax is clunky when you start needing else if.

                                                                                                                                                                                                                                          1. 1

                                                                                                                                                                                                                                            Perhaps they are trying to avoid the C++ thing where you can’t tell whether foo(bar) is struct creation or a function call without knowing what foo is?

                                                                                                                                                                                                                                            Why wouldn’t you be able to tell?

                                                                                                                                                                                                                                            Even if that was the issue (it isn’t), that’s not the problem C++ has – it’s that foo also could be 3 dozen other things.

                                                                                                                                                                                                                                            Would you have preferred […]

                                                                                                                                                                                                                                            No, I prefer having one unified construct that can deal with both usecases reasonably well.

                                                                                                                                                                                                                                            1. 2

                                                                                                                                                                                                                                              Why wouldn’t you be able to tell?

                                                                                                                                                                                                                                              struct M { };
                                                                                                                                                                                                                                              void L(M m);
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              void f() {
                                                                                                                                                                                                                                                  M(m); // e.g. M m;
                                                                                                                                                                                                                                                  L(m); // function call
                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                              The only way to tell what is going on is if you already know the types of all the symbols.

                                                                                                                                                                                                                                              No, I prefer having one unified construct that can deal with both usecases reasonably well.

                                                                                                                                                                                                                                              Ok, do you have an example from another language which you think handles this reasonably well?

                                                                                                                                                                                                                                              1. 2

                                                                                                                                                                                                                                                The only way to tell what is going on is if you already know the types of all the symbols.

                                                                                                                                                                                                                                                Let the IDE color things accordingly. Solved problem.

                                                                                                                                                                                                                                                Ok, do you have an example from another language which you think handles this reasonably well?

                                                                                                                                                                                                                                                I’m currently in the process of implementing it, but I think this is a good intro to my plans.

                                                                                                                                                                                                                                                1. 1

                                                                                                                                                                                                                                                  Let the IDE color things accordingly. Solved problem.

                                                                                                                                                                                                                                                  The problem of course is for the writer of the IDE :)

                                                                                                                                                                                                                                                  Constructs like these in C++ make it not only harder for humans to parse the code, but for compilers as well. This turns into real-world performance decreases which are avoided in other languages.

                                                                                                                                                                                                                                                  I’m currently in the process of implementing it, but I think this is a good intro to my plans.

                                                                                                                                                                                                                                                  That’s interesting, but I think there’s a conflict with Rust’s goal of being a systems-level programming language. Part of that is having primitives which map reasonably well onto things that the compiler can translate into machine code. Part of the reason that languages like C have both if and switch is because switch statements of the correct form may be translated into an indirect jump instead of repeated branches. Of course, a Sufficiently Smart Compiler could optimize this even in the if case, but it is very easy to write code which is not optimizable in such a way. I think there is value to both humans and computers in having separate constructs for arbitrary conditionals and for equality. It helps separate intent and provides some good optimization hints.

                                                                                                                                                                                                                                                  Another reason why this exists is for exhaustiveness checks. Languages with switch can check that you handle all cases of an enum.

                                                                                                                                                                                                                                                  The other half of this is that Rust is the bastard child of ML and C++. ML and C++ both have match/switch, so Rust has one too.


                                                                                                                                                                                                                                                  I think you will have a lot of trouble producing good error messages with such a syntax. For example, say someone forgets an = or even both ==s. If your language does false-y and truth-y coercion, then there may be no error at all here. And to the parser, it is not clear at all where the error is. Further, this sort of extension cannot be generalized to one-liners. That is, you cannot unambiguously parse if a == b then c == d then e without line-breaks.

                                                                                                                                                                                                                                                  On the subject, in terms of prior-art, verilog allows expressions in its case labels. This allows for some similar syntax constructions (though more limited since functions are not as useful as in regular programming languages).

                                                                                                                                                                                                                                          2. 3

                                                                                                                                                                                                                                            For instance, it has different syntax for struct creation and function calls, their poor syntax choices also mean that structs/functions won’t get default values any time soon.

                                                                                                                                                                                                                                            This is a good thing. Creating a struct is a meaningfully different operation from calling a function, and there’s no problem with having there be separate syntax for these two separate things.

                                                                                                                                                                                                                                            The Rust standard library provides a Default trait, with examples of how to use it and customize it. I don’t find it at all difficult to work with structs with default values in Rust.

                                                                                                                                                                                                                                            The whole module stuff is way too complex and only makes sense if you programmed in C before. I have basically given up on getting to know the intricacies, and just let IntelliJ handle uses.

                                                                                                                                                                                                                                            I don’t understand this comment at all. Rust’s module system seems fairly similar to module systems in some other languages I’ve used, although I’m having trouble thinking of other languages that allow you to create a module hierarchy within a single file, like you can do with the mod { } keyword (C++ allows nested namespaces I think, but that’s it). I don’t see how knowing C has anything to do with understand Rust modules better. C has no module system at all.

                                                                                                                                                                                                                                            1. 2

                                                                                                                                                                                                                                              I’m having trouble thinking of other languages that allow you to create a module hierarchy within a single file

                                                                                                                                                                                                                                              Lua can do this, although it’s not common.

                                                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                                                This is a good thing.

                                                                                                                                                                                                                                                I guess that’s why many Rust devs – immediately after writing a struct – also define a fun to wrap their struct creation? :-)

                                                                                                                                                                                                                                                Creating a struct is a meaningfully different operation from calling a function

                                                                                                                                                                                                                                                It really isn’t.

                                                                                                                                                                                                                                                The Rust standard library provides a Default trait, with examples of how to use it and customize it. I don’t find it at all difficult to work with structs with default values in Rust.

                                                                                                                                                                                                                                                That’s clearly not what I alluded to.

                                                                                                                                                                                                                                                I don’t see how knowing C has anything to do with understand Rust modules better. C has no module system at all.

                                                                                                                                                                                                                                                Rust’s module system only makes sense if you keep in mind that it’s main goal is to produce one big ball of compiled code in the end. In that sense, Rust’s module system is a round-about way to describe which parts of the code end up being part of that big ball.

                                                                                                                                                                                                                                                1. 3

                                                                                                                                                                                                                                                  Putting a OCaml hat on:

                                                                                                                                                                                                                                                  • Struct creation and function calls are quite different. In particular it’s good to have structure syntax that can be mirrored in pattern matching, whereas function call has no equivalent in match.
                                                                                                                                                                                                                                                  • Multiple modules in one file is also possible in ML/OCaml. Maybe in some Wirth language, though I’m not sure on that one.

                                                                                                                                                                                                                                                  it’s main goal is to produce one big ball of compiled code in the end.

                                                                                                                                                                                                                                                  What other goal would there be? That’s what 100% of compiled languages aim at… Comparing rust to C which has 0 notion of module is just weird.

                                                                                                                                                                                                                                                  1. 1

                                                                                                                                                                                                                                                    Struct creation and function calls are quite different. In particular it’s good to have structure syntax that can be mirrored in pattern matching, whereas function call has no equivalent in match.

                                                                                                                                                                                                                                                    In what sense would this be an obstacle? I would expect that a modern language let’s you match on anything that provides the required method/has the right signature. “This is a struct, so you can match on it” feels rather antiquated.

                                                                                                                                                                                                                                                    What other goal would there be? That’s what 100% of compiled languages aim at… Comparing rust to C which has 0 notion of module is just weird.

                                                                                                                                                                                                                                                    It feels like it was built by someone who never used anything but C in his life, and then went “wouldn’t it be nice if it was clearer than in C which parts of the code contribute to the result?”.

                                                                                                                                                                                                                                                    The whole aliasing, reexporting etc. functionality feels like it exists as a replacement for some convenience C macros, and not something one actually would want. I prefer that there is a direct relationship between placing a file somewhere and it ending up in a specific place, without having to wire up everything again with the module system.

                                                                                                                                                                                                                                                    1. 1

                                                                                                                                                                                                                                                      There is documented inspiration from OCaml from the rust original creator. The first compiler was even in OCaml, and a lot of names stuck (like Some/None rather than the Haskell Just/Nothing). It also has obvious C++ influences, notably the namespace syntax being :: and <> for generics. The module system most closely reminds me of a mix of OCaml and… python, with special file names (mod.rs, like __init__.py or something like that?), even though it’s much much simpler than OCaml. Again not just “auto wiring” files in is a net benefit (another lesson from OCaml I’d guess, where the build system has to clarify what’s in or out a specific library). It makes build more declarative.

                                                                                                                                                                                                                                                      As for the matching: rust doesn’t have active patterns or the scala-style deconstruction. In this context (match against values you can pre-compile pattern-matching very efficiently to decision trees and constant time access to fields by offset. This would be harder to do efficiently with “just call this deconstuct method”. This is more speculation on my side, but it squares with rust’s efficiency concerns.

                                                                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                                                                        I see your point, but in that case Rust would need to disallow match guards too (because what else are guards, but less reusable unapply methods?).

                                                                                                                                                                                                                                                    2. 1

                                                                                                                                                                                                                                                      Comparing rust to C which has 0 notion of module is just weird.

                                                                                                                                                                                                                                                      Well there are translation units :) (though you can only import using the linker)

                                                                                                                                                                                                                                                  2. 1

                                                                                                                                                                                                                                                    I’m having trouble thinking of other languages that allow you to create a module hierarchy within a single file,

                                                                                                                                                                                                                                                    Perl can do this.

                                                                                                                                                                                                                                                    1. 3

                                                                                                                                                                                                                                                      Elixir also allows you to create a module hierarchy within a single file.

                                                                                                                                                                                                                                                      1. 2

                                                                                                                                                                                                                                                        And Julia. Maybe this isn’t so rare.

                                                                                                                                                                                                                                                  3. 1

                                                                                                                                                                                                                                                    ; is mandatory (what is this, 1980?), but you can leave out , at the end.

                                                                                                                                                                                                                                                    Ugh this one gets me every time. Why Rust, why.

                                                                                                                                                                                                                                                    1. 2

                                                                                                                                                                                                                                                      Same in Zig? Curious to know Zig rationale for this.

                                                                                                                                                                                                                                                      1. 10

                                                                                                                                                                                                                                                        In almost all languages with mandatory semicolons, they exist to prevent multi-line syntax ambiguities. The designers of Go and Lua both went to great pains to avoid such problems in their language grammars. Unlike, for example, JavaScript. This article about semicolon insertion rules causing ambiguity and unexpected results should help illustrate some of these problems.

                                                                                                                                                                                                                                                        1. 3

                                                                                                                                                                                                                                                          Pointing out Javascript isn’t a valid excuse.

                                                                                                                                                                                                                                                          Javascript’s problems are solely Javascript’s. If we discarded every concept that was implemented poorly in Javascript, we wouldn’t have many concepts left to program with.

                                                                                                                                                                                                                                                          I want semicolon inference done right, simple as that.

                                                                                                                                                                                                                                                          1. 4

                                                                                                                                                                                                                                                            That’s not what I’m saying. JavaScript is merely an easy example of some syntax problems that can occur. I merely assume that Rust, which has many more features than Go or Lua, decided not to maintain an unambiguous grammar without using semicolons.

                                                                                                                                                                                                                                                            1. 2

                                                                                                                                                                                                                                                              Why would the grammar be ambiguous? Are you sure that you don’t keep arguing from a JavaScript POV?

                                                                                                                                                                                                                                                              Not needing ; doesn’t mean the grammar is ambiguous.

                                                                                                                                                                                                                                                              1. 4

                                                                                                                                                                                                                                                                ~_~

                                                                                                                                                                                                                                                                Semicolons are an easy way to eliminate grammar ambiguity for multi-line syntax. For any language. C++ for example would have numerous similar problems without semicolons.

                                                                                                                                                                                                                                                                Not needing ; doesn’t mean the grammar is ambiguous.

                                                                                                                                                                                                                                                                Of course. Go and Lua are examples of languages designed specifically to avoid ambiguity without semicolons. JavaScript, C++, and Rust were not designed that way. JavaScript happens to be an easy way to illustrate possible problems because it has janky automatic semicolon insertion, whereas C++ and Rust do not.

                                                                                                                                                                                                                                                                1. 0

                                                                                                                                                                                                                                                                  I’m completely unsure what you are trying to argue – it doesn’t make much sense. Has your triple negation above perhaps confused you a bit?

                                                                                                                                                                                                                                                                  The main point is that a language created after 2000 simply shouldn’t need ;.

                                                                                                                                                                                                                                                                  1. 5

                                                                                                                                                                                                                                                                    ; is mandatory (what is this, 1980?), but you can leave out , at the end.

                                                                                                                                                                                                                                                                    Same in Zig? Curious to know Zig rationale for this.

                                                                                                                                                                                                                                                                    The rationale for semicolons. They make parsing simpler, particularly for multi-line syntax constructs. I have been extremely clear about this the entire time. I have rephrased my thesis multiple times:

                                                                                                                                                                                                                                                                    In almost all languages with mandatory semicolons, they exist to prevent multi-line syntax ambiguities.

                                                                                                                                                                                                                                                                    Semicolons are an easy way to eliminate grammar ambiguity for multi-line syntax.

                                                                                                                                                                                                                                                                    Many underestimate the difficulty of creating a language without semicolons. Go has done so with substantial effort, and maintaining that property has by no means been effortless for them when adding new syntax to the language.

                                                                                                                                                                                                                                                                    1. 0

                                                                                                                                                                                                                                                                      Yeah, you know, maybe we should stop building languages that are so complex that they need explicitly inserted tokens to mark “previous thing ends here”? That’s the point I’m making.

                                                                                                                                                                                                                                                                      when adding new syntax to the language

                                                                                                                                                                                                                                                                      Cry me a river. Adding features does not improve a language.

                                                                                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                                                                                        Having a clear syntax where errors don’t occur 15 lines below the missing ) or } (as would unavoidably happen without some separator — trust me, it’s one of OCaml’s big syntax problems for toplevel statements) is a net plus and not bloat.

                                                                                                                                                                                                                                                                        What language has no semicolon (or another separator, or parenthesis, like lisp) and still has a simple syntax? Even python has ; for same-line statements. Using vertical whitespace as a heuristic for automatic insertion isn’t a win in my book.

                                                                                                                                                                                                                                                                        1. 2

                                                                                                                                                                                                                                                                          Both Kotlin and Swift have managed to make a working , unambiguous C-like syntax without semicolons.

                                                                                                                                                                                                                                                                          1. 2

                                                                                                                                                                                                                                                                            I didn’t know. That involves no whitespace/lexer trick at all? I mean, if you flatten a whole file into one line, does it still work? Is it still in LALR(1)/LR(1)/some nice fragment?

                                                                                                                                                                                                                                                                            The typical problem in this kind of grammar is that, while binding constructs are easy to delimit (var/val/let…), pure sequencing is not. If you have a = 1 b = 2 + 3 c = 4 d = f(a) semicolons make things just simpler for the parser.

                                                                                                                                                                                                                                                                            1. 1

                                                                                                                                                                                                                                                                              Why are line breaks not allowed to be significant? I don’t think I care if I can write an arbitrarily long program on one line…

                                                                                                                                                                                                                                                                          2. 0

                                                                                                                                                                                                                                                                            Using vertical whitespace as a heuristic for automatic insertion isn’t a win in my book.

                                                                                                                                                                                                                                                                            I agree completely. I love Lua in particular. You can have zero newlines yet it requires no semicolons, due to its extreme simplicity. Lua has only one ambiguous case: when a line begins with a ( and the previous line ends with a value.

                                                                                                                                                                                                                                                                            a = b
                                                                                                                                                                                                                                                                            (f or g)() -- call f, or g when f is nil
                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                            Since Lua has no semantic newlines, this is exactly equivalent to:

                                                                                                                                                                                                                                                                            a = b(f or g)()
                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                            The Lua manual thus recommends inserting a ; before any line starting with (.

                                                                                                                                                                                                                                                                            a = b
                                                                                                                                                                                                                                                                            ;(f or g)()
                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                            But I have never needed to do this. And if I did, I would probably write this instead:

                                                                                                                                                                                                                                                                            a = b
                                                                                                                                                                                                                                                                            local helpful_explanatory_name = f or g
                                                                                                                                                                                                                                                                            helpful_explanatory_name()
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                          2. 3

                                                                                                                                                                                                                                                            Also curious, as well as why Zig uses parentheses in ifs etc. I know what I’ll say is lame, but those two things frustrate me when looking at Zig’s code. If I could learn the rationale, it might hopefully at least make those a bit easier for me to accept and get over.

                                                                                                                                                                                                                                                            1. 3

                                                                                                                                                                                                                                                              One reason for this choice is to remove the need for a ternary operator without greatly harming ergonomics. Having the parentheses means that the blocks may be made optional which allows for example:

                                                                                                                                                                                                                                                              const foo = if (bar) a else b;
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              1. 8

                                                                                                                                                                                                                                                                There’s a blog post by Graydon Hoare that I can’t find at the moment, where he enumerates features of Rust he thinks are clear improvements over C/C++ that have nothing to do with the borrow checker. Forcing if statements to always use braces is one of the items on his list; which I completely agree with. It’s annoying that in C/C++, if you want to add an additional line to a block of a brace-less if statement, you have to remember to go back and add the braces; and there have been major security vulnerabilities caused by people forgetting to do this.

                                                                                                                                                                                                                                                                1. 6
                                                                                                                                                                                                                                                                2. 6

                                                                                                                                                                                                                                                                  The following would work just as well:

                                                                                                                                                                                                                                                                  const foo = if bar { a } else { b };
                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                  I’ve written an expression oriented language, where the parenthesis were optional, and the braces mandatory. I could use the exact same syntactic construct in regular code and in the ternary operator situation.

                                                                                                                                                                                                                                                                  Another solution is inserting another keyword between the condition and the first branch, as many ML languages do:

                                                                                                                                                                                                                                                                  const foo = if bar then a else b;
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                                                                                    I don’t get how that’s worth making everything else ugly. I imagine there’s some larger reason. The parens on ifs really do feel terrible after using go and rust for so long.

                                                                                                                                                                                                                                                                    1. 1

                                                                                                                                                                                                                                                                      For what values of a, b, c would this be ambiguous?

                                                                                                                                                                                                                                                                      const x = if a b else c
                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                      I guess it looks a little ugly?

                                                                                                                                                                                                                                                                      1. 5

                                                                                                                                                                                                                                                                        If b is actually a parenthesised expression like (2+2), then the whole thing looks like a function call:

                                                                                                                                                                                                                                                                        const x = if a (2+2) else c
                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                        Parsing is no longer enough, you need to notice that a is not a function. Lua has a similar problem with optional semicolon, and chose to interpret such situations as function calls. (Basically, a Lua instruction stops as soon as not doing so would cause a parse error).

                                                                                                                                                                                                                                                                        Your syntax would make sense in a world of optional semicolons, with a parser (and programmers) ready to handle this ambiguity. With mandatory semicolons however, I would tend to have mandatory curly braces as well:

                                                                                                                                                                                                                                                                        const x = if a { b } else { c };
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        1. 4

                                                                                                                                                                                                                                                                          Ah, Julia gets around this by banning whitespace between the function name and the opening parenthesis, but I know some people would miss that extra spacing.

                                                                                                                                                                                                                                                                        2. 3
                                                                                                                                                                                                                                                                          abs() { x = if a < 0 - a else a }
                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                          1. 1

                                                                                                                                                                                                                                                                            Thanks for the example!

                                                                                                                                                                                                                                                                            I think this is another case where banning bad whitespace makes this unambiguous.

                                                                                                                                                                                                                                                                            a - b => binary
                                                                                                                                                                                                                                                                            -a => unary
                                                                                                                                                                                                                                                                            a-b => binary
                                                                                                                                                                                                                                                                            a -b => error
                                                                                                                                                                                                                                                                            a- b => error
                                                                                                                                                                                                                                                                            - a => error
                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                            You can summarise these rules as “infix operators must have balanced whitespace” and “unary operators must not be followed by whitespace”.

                                                                                                                                                                                                                                                                            Following these rules, your expression is unambiguously a syntax error, but if you remove the whitespace between - and a it works.

                                                                                                                                                                                                                                                                            1. 1

                                                                                                                                                                                                                                                                              Or you simply ban unary operators.

                                                                                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                                                                                Sure, seems a bit drastic, tho. I like unary logical not, and negation is useful sometimes too.

                                                                                                                                                                                                                                                                                1. 1

                                                                                                                                                                                                                                                                                  Not sure how some cryptic operator without working jump-to-declaration is better than some bog-standard method …

                                                                                                                                                                                                                                                                                  1. 1

                                                                                                                                                                                                                                                                                    A minus sign before a number to indicate a negative number is probably recognizable as a negative number to most people in my country. I imagine most would recognise -x as “negative x”, too. Generalising that to other identifiers is not difficult.

                                                                                                                                                                                                                                                                                    An exclamation mark for boolean negation is less well known, but it’s not very difficult to learn. I don’t see why jump-to should fail if you’re using a language server, either.

                                                                                                                                                                                                                                                                                    More generally, people have been using specialist notations for centuries. Some mathematicians get a lot of credit for simply inventing a new way to write an older concept. Maybe we’d be better off with only named function calls, maybe our existing notations are made obsolete by auto-complete, but I am not convinced.

                                                                                                                                                                                                                                                              2. 9

                                                                                                                                                                                                                                                                My current feeling is that async/await is the worst way to express concurrency … except for all the other ways.

                                                                                                                                                                                                                                                                I have only minor experience with it (in Nim), but a good amount of experience with concurrency. Doing it with explicit threads sends you into a world of pain with mutexes everywhere and deadlocks and race conditions aplenty. For my current C++ project I built an Actor library atop thread pools (or dispatch queues), which works pretty well except that all calls to other actors are one-way so you now need callbacks, which become painful. I’m looking forward to C++ coroutines.

                                                                                                                                                                                                                                                                1. 3

                                                                                                                                                                                                                                                                  except for all the other ways

                                                                                                                                                                                                                                                                  I think people are complaining about the current trend to just always use async for everything. Which ends up complaining about rust having async at all.

                                                                                                                                                                                                                                                                2. 8

                                                                                                                                                                                                                                                                  This is amazing. I had similar feelings (looking previously at JS/Scala futures) when the the plans for async/await were floating around but decided to suspend my disbelief because of how good previous design decisions in the language were. Do you think there’s some other approach to concurrency fit for a runtime-less language that would have worked better?

                                                                                                                                                                                                                                                                  1. 17

                                                                                                                                                                                                                                                                    My belief is generally that threads as they exist today (not as they existed in 2001 when the C10K problem was written, but nevertheless keeps existing as zombie perf canon that no longer refers to living characteristics) are the nicest choice for the vast majority of use cases, and that Rust-style executor-backed tasks are inappropriate even in the rare cases where M:N pays off in languages like Go or Erlang (pretty much just a small subset of latency-bound load balancers that don’t perform very much CPU work per socket). When you start caring about millions of concurrent tasks, having all of the sources of accidental implicit state and interactions of async tasks is a massive liability.

                                                                                                                                                                                                                                                                    I think The ADA Ravenscar profile (see chapter 2 for “motivation” which starts at pdf page 7 / marked page 3) and its successful application to safety critical hard real time systems is worth looking at for inspiration. It can be broken down to this set of specific features if you want to dig deeper. ADA has a runtime but I’m kind of ignoring that part of your question since it is suitable for hard real-time. In some ways it reminds me of an attempt to get the program to look like a pretty simple petri net.

                                                                                                                                                                                                                                                                    I think that message passing and STM are not utilized enough, and when used judiciously they can reduce a lot of risk in concurrent systems. STM can additionally be made wait-free and thus suitable for use in some hard real-time systems.

                                                                                                                                                                                                                                                                    I think that Send and Sync are amazing primitives, and I only wish I could prove more properties at compile time. The research on session types is cool to look at, and you can get a lot of inspiration about how to encode various interactions safely in the type system from the papers coming out around this. But it can get cumbersome and thus create more risks to the overall engineering effort than it solves if you’re not careful.

                                                                                                                                                                                                                                                                    A lot of the hard parts of concurrency become a bit easier when we’re able to establish maximum bounds on how concurrent we’re going to be. Threads have a little bit more of a forcing function to keep this complexity minimized due to the fact that spawning is fallible due to often under-configured system thread limits. Having fixed concurrency avoids many sources of bugs and performance issues, and enables a lot of relatively unexplored wait-free algorithmic design space that gets bounded worst-case performance (while still usually being able to attempt a lock-free fast path and only falling back to wait-free when contention picks up). Structured concurrency often leans into this for getting more determinism, and I think this is an area with a lot of great techniques for containing risk.

                                                                                                                                                                                                                                                                    In the end we just have code and data and risk. It’s best to have a language with forcing functions that pressure us to minimize all of these over time. Languages that let you forget about accruing data and code and risk tend to keep people very busy over time. Friction in some places can be a good thing if it encourages less code, less data, and less risk.

                                                                                                                                                                                                                                                                    1. 17

                                                                                                                                                                                                                                                                      I like rust and I like threads, and do indeed regret that most libraries have been switching to async-only. It’s a lot more complex and almost a new sub-language to learn.

                                                                                                                                                                                                                                                                      That being said, I don’t see a better technical solution for rust (i.e. no mandatory runtime, no implicit allocations, no compromise on performance) for people who want to manage millions of connections. Sadly a lot of language design is driven by the use case of giant internet companies in the cloud and that’s a problem they have; not sure why anyone else cares. But if you want to do that, threads start getting in the way at 10k threads-ish? Maybe 100k if you tune linux well, but even then the memory overhead and latency are not insignificant, whereas a future can be very tiny.

                                                                                                                                                                                                                                                                      Ada’s tasks seem awesome but to the best of my knowledge they’re for very limited concurrency (i.e the number of tasks is small, or even fixed beforehand), so it’s not a solution to this particular problem.

                                                                                                                                                                                                                                                                      Of course async/await in other languages with runtimes is just a bad choice. Python in particular could have gone with “goroutines” (for lack of a better word) like stackless python already had, and avoid a lot of complexity. (How do people still say python is simple?!). At least java’s Loom project is heading in the right direction.

                                                                                                                                                                                                                                                                      1. 11

                                                                                                                                                                                                                                                                        Just like some teenagers enjoy making their slow cars super loud to emulate people who they look up to who drive fast cars, we all make similar aesthetic statements when we program. I think I may write on the internet in a way that attempts to emulate a grumpy grey-beard for similarly aesthetic socially motivated reasons. The actual effect of a program or its maintenance is only a part of our expression while coding. Without thinking about it, we also code as an expression of our social status among other coders. I find myself testing random things with quickcheck, even if they don’t actually matter for anything, because I think of myself as the kind of person who tests more than others. Maybe it’s kind of chicken-and-egg, but I think maybe we all do these things as statements of values - even to ourselves even when nobody else is looking.

                                                                                                                                                                                                                                                                        Sometimes these costumes tend to work out in terms of the effects they grant us. But the overhead of Rust executors is just perf theater that comes with nasty correctness hazards, and it’s not a good choice beyond prototyping if you’re actually trying to build a system that handles millions of concurrent in-flight bits of work. It locks you into a bunch of default decisions around QoS, low level epoll behavior etc… that will always be suboptimal unless you rewrite a big chunk of the stack yourself, and at that point, the abstraction has lost its value and just adds cycles and cognitive complexity on top of the stack that you’ve already fully tweaked.

                                                                                                                                                                                                                                                                        1. 3

                                                                                                                                                                                                                                                                          The green process abstraction seems to work well enough in Erlang to serve tens of thousands of concurrent connections. Why do you think the async/await abstraction won’t work for Rust? (I understand they are very different solutions to a similar problem.)

                                                                                                                                                                                                                                                                          1. 4

                                                                                                                                                                                                                                                                            Not who you’re asking, but the reason why rust can’t have green threads (as it used to have pre-1.0, and it was scraped), as far as I undertand:

                                                                                                                                                                                                                                                                            Rust is shooting for C or C++-like levels of performance, with the ability to go pretty close to the metal (or close to whatever C does). This adds some constraints, such as the necessity to support some calling conventions (esp. for C interop), and precludes the use of a GC. I’m also pretty sure the overhead of the probes inserted in Erlang’s bytecode to check for reduction counts in recursive calls would contradict that (in rust they’d also have to be in loops, btw); afaik that’s how Erlang implements its preemptive scheduling of processes. I think Go has split stacks (so that each goroutine takes less stack space) and some probes for preemption, but the costs are real and in particular the C FFI is slower as a result. (saying that as a total non-expert on the topic).

                                                                                                                                                                                                                                                                            I don’t see why async/await wouldn’t work… since it does; the biggest issues are additional complexity (a very real problem), fragmentation (the ecosystem hasn’t converged yet on a common event loop), and the lack of real preemption which can sometimes cause unfairness. I think Tokio hit some problems on the unfairness side.

                                                                                                                                                                                                                                                                            1. 3

                                                                                                                                                                                                                                                                              The biggest problem with green threads is literally C interop. If you have tiny call stacks, then whenever you call into C you have to make sure there’s enough stack space for it, because the C code you’re calling into doesn’t know how to grow your tiny stack. If you do a lot of C FFI, then you either lose the ability to use small stacks in practice (because every “green” thread winds up making an FFI call and growing its stack) or implementing some complex “stack switching” machinery (where you have a dedicated FFI stack that’s shared between multiple green threads).

                                                                                                                                                                                                                                                                              Stack probes themselves aren’t that big of a deal. Rust already inserts them sometimes anyway, to avoid stack smashing attacks.

                                                                                                                                                                                                                                                                              In both cases, you don’t really have zero-overhead C FFI any more, and Rust really wants zero-overhead FFI.

                                                                                                                                                                                                                                                                              I think Go has split stacks (so that each goroutine takes less stack space)

                                                                                                                                                                                                                                                                              No they don’t any more. Split Stacks have some really annoying performance cliffs. They instead use movable stacks: when they run out of stack space, they copy it to a larger allocation, a lot like how Vec works, with all the nice “amortized linear” performance patterns that result.

                                                                                                                                                                                                                                                                            2. 3

                                                                                                                                                                                                                                                                              Two huge differences:

                                                                                                                                                                                                                                                                              • Erlang’s data structures are immutable (and it has much slower single threaded speed).
                                                                                                                                                                                                                                                                              • Erlang doesn’t have threads like Rust does.

                                                                                                                                                                                                                                                                              That changes everything with regard to concurrency, so you can’t really compare the two. A comparison to Python makes more sense, and Python async has many of the same problems (mutable state, and the need to compose with code and libraries written with other concurrency models)

                                                                                                                                                                                                                                                                        2. 4

                                                                                                                                                                                                                                                                          I’d like to see a good STM implementation in a library in Rust.

                                                                                                                                                                                                                                                                      2. 6

                                                                                                                                                                                                                                                                        The fixation on async-await, despite it slowing down almost every real-world workload it is applied to, and despite it adding additional bug classes and compiler errors that simply don’t exist unless you start using it, has been particularly detrimental to the ecosystem.

                                                                                                                                                                                                                                                                        I’m curious about this perspective. The number of individual threads available on most commodity machines even today is quite low, and if you’re doing anything involving external requests on an incoming-request basis (serializing external APIs, rewriting HTML served by another site, reading from slow disk, etc) and these external requests take anything longer than a few milliseconds (which is mostly anything assuming you have a commodity connection in most parts of the world, or on slower disks), then you are better off with a some form of “async” (or otherwise lightweight concurrent model of execution.) I understand that badly-used synchronization can absolutely tank performance with this many “tasks”, but in situations where synchronization is low (e.g. making remote calls, storing state in a db or separate in-memory cache), performance should be better than threaded execution.

                                                                                                                                                                                                                                                                        Also, if I reach for Rust I’m deliberately avoiding GC. Go, Python, and Haskell are the languages I tend to reach for if I just want to write code and not think too hard about who owns which portion of data or how exactly the runtime schedules my code. With Rust I’m in it specifically to think about these details and think hard about them. That means I’m more prone to write complicated solutions in Rust, because I wouldn’t reach for Rust if I wanted to write something “simple and obvious”. I suspect a lot of other Rust authors are the same.

                                                                                                                                                                                                                                                                        1. 5

                                                                                                                                                                                                                                                                          The number of individual threads available on most commodity machines even today is quite low

                                                                                                                                                                                                                                                                          I don’t agree with the premise here. It depends more on the kernel, not the “machine”, and Linux in particular has very good threading performance. You can have 10,000 simultaneous threads on vanilla Linux on a vanilla machine. async may be better for certain specific problems, but that’s not the claim.

                                                                                                                                                                                                                                                                          Also a pure async model doesn’t let you use all your cores, whereas a pure threading model does. If you really care about performance and utilization, your system will need threads or process level concurrency in some form.

                                                                                                                                                                                                                                                                          1. 4

                                                                                                                                                                                                                                                                            I don’t agree with the premise here. It depends more on the kernel, not the “machine”, and Linux in particular has very good threading performance. You can have 10,000 simultaneous threads on vanilla Linux on a vanilla machine. async may be better for certain specific problems, but that’s not the claim.

                                                                                                                                                                                                                                                                            I wasn’t rigorous enough in my reply, apologies.

                                                                                                                                                                                                                                                                            What I meant to say was, the number of cores available on a commodity machine is quite low. Even if you spawn thousands of threads, your actual thread-level parallelism is limited to the # of cores available. If you’re at the point where you need to spawn more kernel threads than there are available cores, then you need to put engineering into determining how many threads to create and when. For IO bound workloads (which I described in my previous post), the typical strategy is to create a thread pool, and to allocate threads from this pool. Thread pools themselves are a solution so that applications don’t saturate available memory with threads and so you don’t overwhelm the kernel with time spent switching threads. At this point, your most granular “unit of concurrency” is each thread in this thread pool. If most of your workload is IO bound, you end up having to play around with your thread pool sizes to ensure that your workload is processed without thread contention on the one hand (too few threads) or up against resource limits (too many threads). You could of course build a more granular scheduler atop these threads, to put threads “to sleep” once they begin to wait on IO, but that is essentially what most async implementations are, just optimizations on “thread-grained” applications. Given that you’re already putting in the work to create thread pools and all of the fiddly logic with locking the pool, pulling out a thread, then locking and putting threads back, it’s not a huge lift to deal with async tasks. Of course if your workload is CPU bound, then these are all silly, as your main limiting resource is not IO but is CPU, so performing work beyond the amount of available CPU you have necessitates queuing.

                                                                                                                                                                                                                                                                            Moreover the context with which I was saying this is that most Rust async libraries I’ve seen are async because they deal with IO and not CPU, which is what async models are good at.

                                                                                                                                                                                                                                                                          2. 3

                                                                                                                                                                                                                                                                            Various downsides are elaborated at length in this thread.

                                                                                                                                                                                                                                                                            1. 2

                                                                                                                                                                                                                                                                              Thanks for the listed points. What it’s made me realize is that there isn’t really a detailed model which allows us to demonstrate tradeoffs that come with selecting an async model vs a threaded model. Thanks for some food for thought.

                                                                                                                                                                                                                                                                              My main concern with Rust async is mostly just its immaturity. Forget the code semantics; I have very little actual visibility into Tokio’s (for example) scheduler without reading the code. How does it treat many small jobs? Is starvation a problem, and under what conditions? If I wanted to write a high reliability web service with IO bound logic, I would not want my event loop to starve a long running request that may have to wait longer on IO than a short running request and cause long running requests to timeout and fail. With a threaded model and an understanding of my IO processing latency, I can ensure that I have the correct # of threads available with some simple math and not be afraid of things like starvation because I trust the Linux kernel thread scheduler much more than Tokio’s async scheduler.

                                                                                                                                                                                                                                                                          3. 3

                                                                                                                                                                                                                                                                            There’s no if-statement community

                                                                                                                                                                                                                                                                            That had me laughing out loud!

                                                                                                                                                                                                                                                                            1. 2

                                                                                                                                                                                                                                                                              probably because it’s if-expressions 🙃

                                                                                                                                                                                                                                                                            2. 2

                                                                                                                                                                                                                                                                              I hope I’m not opening any wounds or whacking a bee-hive for asking but… what sort of problematic interactions occur with the Rust community? I follow Rust mostly as an intellectual curiosity and therefor aren’t in deep enough to see the more annoying aspects. When I think of unprofessional language community behavior my mind mostly goes to Rails during the aughts when it was just straight-up hostile towards Java and PHP stuff. Is Rust doing a similar thing to C/C++?