1. 3

    The text only hints at it, but I would highly recommend using std::ptr::NonNull for the raw pointer for multiple reasons: a) it communicates an additional invariant to the user and b) rustc knows that NonNull has an illegal value (NULL) and uses that value as a niche to optimise enums. Especially sizeof(Option<NonNull<c_void>>) == sizeof(*mut c_void).

    1. 14

      For those interested, substantial parts of the book discussed can be found here: https://sandimetz.com/99bottles-sample-ruby, especially chapter 1.

      To be quite frank, if someone runs post chapter 1 and says “In the first chapter, the author contrasts 4 versions of a program generating the text of the “99 bottles of Beer” song. They are all effectively the same, with 3 of them being slightly too clever, and one being a clear simplicity winner.”, they have run past the point of the book. None of the examples given are super contrived (I would even go as far an saying that they spot-on illustrate malpractice in the Ruby community), the book uses the comparison to introduce some terms and it picks an common problem that many people know about. But the point that the author makes super clear leading up to those examples is that there are cases where aspects of each can be the proper solution.

      I don’t want to argue the quality of the book (I haven’t read it, I only know Sandi Metz for her talks), but seemingly trivial examples are what make accessible teaching material. Any transformation of those examples to a different practice are easy to make - that means learners can quickly follow and change examples themselves. It’s entirely okay to bring out the big guns for a small example for the sake of learning.

      1. 4

        I have read the book (first edition not the new one). It was great. To me, disliking it is a sign of poor taste. It’s a totally thoughtful book for programmers at any skill level to benefit from. If you don’t like it, you probably don’t like programming.

      1. 20

        Apparently firefox has always been using unstable features of rust? https://news.ycombinator.com/item?id=27492520

        1. 8

          Yes, and some Rust team members are highly critical of this, precisely because it is a hallmark project and produces the impression laid out in the blog post.

          1. 4

            Except this time, the cause was something completely different, as noted by matklad elsewhere in this thread. It’s pretty uncool that the blog post author didn’t post the error message up front and gave room for speculation.

            1. 3

              I don’t normally like to criticize this way, but this is a bit of a pattern for the author. It might be coming to your attention for the first time here because of the specific context, but I’ve been frustrated more than once by their posts claiming backwards-compatibility issues in things I’m more involved in/attentive to, because they so often don’t include enough detail for someone to dig in and figure out what the cause was.

              1. 1

                You are correct and sorry for falling into that trap!

          1. 24

            Dunno…given the description of actual behavior rather than pejorative value judgements, I would much rather have Alice on my team than people who criticise her, and would find it more likely that they are the jerks (or bullies, to be more precise).

            In my experience, workplaces that frown on Alices are nice, but not kind, and actually have way more underhandedness and backstabbing.

            1. 26

              I think the problem here is isolating people and their behaviour. I enjoy blunt and direct people around me. I even encourage them, it gives me clarity. I even prefer them, I don’t need to decode them. Sometimes, people see me with a person that I enjoy working with and are like “they treat you hard” and I have to tell them that this is how I want it. Fast. Clear. Cut me off if you got my point and agree or disagree. I’m okay with people being grumpy on a day or - given that I run projects of global scope - people just being tired and through that sometimes not take the mental load of choosing every word carefully. I would still expect those people to treat other people differently and not approach me this way right away.

              The blog post does not talk about sources of Alices behaviour. For example, Alice may take this approach because her feedback is never addressed, which is quite different category of a jerk than someone who just makes that their persona and feels good in it.

              My problem with niceness is: it’s highly cultural. It’s a category that is immediately exclusive e.g. to foreigners. A lot of people find different cultures behaving “nice” actually odd and weird and are insecure around them. For someone who’s third-language English, it may be a struggle to fulfill those requirements. I’ve definitely seen writing of e.g. people writing in English as a foreign language being framed as jerky just because it was direct and to the point and omitted some amount of fluff. When I approached those people, the reason was simple: they already spent more time than others on formulating their point right, the “niceness” would even incur more cost to them.

              There are jerks out there. But we need to be careful that perceived jerks also exist.

              I also agree with your underhandedness and backstabbing reading. “nice” cultures tend to be conflict-avoidant and conflict always finds its way.

              It’s okay to formulate sharp boundaries around the edges (e.g. using peoples identity to attack their points), but inside of those boundaries, communication is a group exercise and curiosity and willingness to understand other people needs to apply, especially in a more and more interconnected world.

              1. 7

                I think the crux is that there’s an entire “taxonomy of jerks” one could make; Alice doesn’t sound too bad, and Bob sounds like a right cunt. But in between those two there’s a whole lot of other jerks.

                Take the “this is one true only correct way to do it, anyone who disagrees is an idiot, and I will keep forcing my views through ad nauseam even when the entire team has already decided against them”-kind of jerk. These are “selfless jerks” in a way, but can be super toxic and demotivating if not dealt with properly by management. These people don’t even need to be abrasive as such (although they can be) and can be very polite, they just keep starting the same tired old discussions all the time.

                They’re not like Bob’s “selfish jerk”, and genuinely think they’re doing it in the good for the company.

                I once called out such an jerk as an “asshole” in a GitHub comment when he reverted my commit without discussion; that commit fixed some parts of our documentation toolchain. The change was a trivial one: it changed a lower-case letter to a capital one one in a Go import path, which is what we used everywhere else. Perhaps unfortunate that the capital was used, but fixing that would be a lot of work and inconvenience on people’s local dev machines (not all of whom are dedicated Go devs) so after discussing this at length we decided to just stick with the capital.

                Yet he sneaked it in anyway, in spite of the previous consensus of just a few weeks prior, while simply calling the toolchain “broken” and reverted my fix (a toolchain I spent quite some time on outside of my regular work duties I might add, and it’s wasn’t broken; Go import paths are just case-sensitive and it didn’t account for two import paths differing only in case, dealing with that is actually an entire can of worms I did already look in to and discussed with him when we talked about changing this company-wide).

                From the outset I looked like the “perceived jerk”, as you put it, as I swore at him in frustration while he was perfectly polite, but that ignores all the context that we had already discussed this before, came to an agreement, that he decided to just ignore this, and kept forcing his opinion through, and that this was the umpteenth subject on which this happened. HR didn’t see it that way though, “because it’s inappropriate to call people assholes”. True I suppose, but … yeah. And trust me, “asshole” was the filtered polite response and was subtle compared to what I had typed (bit didn’t send) originally.

                It’s almost devious and underhanded in a way, especially the taking offence at the “asshole” part and harping on about that while refusing to discus your own toxic “polite” behaviour. Having to deal with this kind of bullshit for years was a major reason I got burned out at that job, and I’m from the Netherlands which is probably one of the most direct no-nonsense cultures there is.

                My point is: politeness is not unimportant, but often overrated, especially in a context where you all know each other and know perfectly well that they’re just the abrasive sort but are basically just decent folk (it’s different on a public forum like Lobsters and such).


                Adding to that, I’ve definitely been a “perceived jerk”. Communicating over text is hard; my culture is very direct and also kind of sweary, and even as a skilled non-native speaker at times it can be difficult to fully grasp the subtleties of how something is perceived by native speakers. In all the COVID craze of “remote work is the dog’s bollocks and the future” I think people are forgetting about how hard all of this is, and why I’m skeptical that remote work really is the future (but that’s a different discussion…) It’s probably also a major reason for a lot of Open Source drama.

                I’ve had quite a few people tell me “I thought you were a jerk until I met you in person”, a major reason I always went out of my way to meet new people face-to-face for a pint at the pub (not always easy, since we had people world-wide). I tried very hard to change this, and I think I’ve mostly succeeded at it, but it was a lot of active effort that took years.

                1. 2

                  I also fully agree with you there. I have worked as a moderator for years and before I engage e.g. in the whole thing I wrote above I do an assessment whether it’s worth figuring out. Someone jumping on a board, registering an account and blowing off steam with the first comment? => kick But someone going on a long and unfair rant after 12 months of participation? Let’s check out what happened, rather than taking all he said at face value.

                  While I’d love to give every person the benefit of doubt and a long conversation, the day has 24 hours and this assessment must be done. But usually, if that assessment must be done, we’re talking about 1-2h chatting, which is manageable.

                  Adding to that, I’ve definitely been a “perceived jerk”. Communicating over text is hard; my culture is very direct and also kind of sweary, and even as a skilled non-native speaker at times it can be difficult to fully grasp the subtleties of how something is perceived by native speakers. In all the COVID craze of “remote work is the dog’s bollocks and the future” I think people are forgetting about how hard all of this is, and why I’m skeptical that remote work really is the future (but that’s a different discussion…) It’s probably also a major reason for a lot of Open Source drama.

                  I have a bit of a handle on that, interestingly because I got trained in international relationships and marketing. The trick is as easy as it is hard to consistently implement: Always voice your feelings clearly. “I am frustrated that…”. “I am happy that”. Cut tons of slack and assume good faith.

                  “Lack of training” is also a hard problem in open source.

                  I’ve had quite a few people tell me “I thought you were a jerk until I met you in person”, a major reason I always went out of my way to meet new people face-to-face for a pint at the pub (not always easy, since we had people world-wide). I tried very hard to change this, and I think I’ve mostly succeeded at it, but it was a lot of active effort that took years.

                  Same :).

                  1. 2

                    I have a bit of a handle on that, interestingly because I got trained in international relationships and marketing. The trick is as easy as it is hard to consistently implement: Always voice your feelings clearly. “I am frustrated that…”. “I am happy that”. Cut tons of slack and assume good faith.

                    I’ve independently discovered the same trick as well. I also wish people would do this more in political/social justice discussions and the like, e.g. “I feel [X] by [Y] because [Z]” rather than “[X] is [Y]!”, but okay, let’s not side-track this too much 🙃

                    I wish people would give more feedback on his type of stuff in general. I once heard through a co-worker “hey, Bob has a real problem with you, I don’t know why”, “oh wow, I had no idea”. I followed up on this later by just asking him and it turned it was some really simple stuff like PR review comments “just do [X]?” being taken as passive-aggressive. I can (now) see how it was taken like that, but that wasn’t my intention at all. So I explained that, apologized, slightly adjusted the phrasing of my comments, and we actually became quite good friends after this (still are). But if I hadn’t been told this while drunk at 3am in some pub by another coworker then … yeah.

                    Granted, not everyone responds well to this kind of feedback; but if you don’t try you’ll never know, and the potential benefits can be huge, especially in the workplace where you’re “stuck” with the same people for hours every day. I can close a website if I don’t like it; bit harder to do that with your job.

                    I found that communicating with native English speakers in general (much) harder than communicating with other non-native proficient speakers. Maybe we should just go back to Latin so everyone’s a non-native speaker.

              2. 8

                In my experience, workplaces that frown on Alices are nice, but not kind, and actually have way more underhandedness and backstabbing.

                Extreme examples of this from the real-world,

                The leadership style in Elm is extremely aggressive and authoritarian.

                By that I do not mean impolite or rude. It is almost always very civil. But still ultimately aggressive and controlling. — Luke Plant

                … once enough people are piling on to complain or tell you what’s wrong with what you did, you’re going to feel attacked - even if every single comment is worded politely and respectfully. — StackExchange

                1. 3

                  Yeah, if someone (or the news) tells me what to think about someone, without telling (or far better SHOWING) me exactly what they did, I tend to just reserve judgement. Even then, it’s easy to make someone look like the jerk by omission of important information.

                1. 9

                  Bet you a dollar that professional musicians are even more obsessive about their tooling than we are

                  1. 5

                    Eric Clapton’s Magic Wood Block™ is being sold for $21.

                    Then you have the whole discussion whether or not it matters which type of wood your electric guitar’s body uses, and if so, which type of wood is the “best”. You think Vim vs. Emacs is a religious war? Hah! Kid’s stuff.

                    1. 2

                      Fun aside: for me, it’s €17.91.. plus €8,103.70 shipping.

                      1. 4

                        For that price I’d expect Eric Clapton himself to deliver it to me.

                    2. 4

                      Professional drivers vary from gearhead to just rolling down the windows.

                      Doctors have minor holy wars over details of and entire plans for procedures.

                      Builders have strong brand opinions and stronger tool choice. “Young people may use miter saws but I was always faster and cleaner with a circular saw. “

                      Seamstresses have very strong ideas, but tend to agree about the stuff that matters more.

                      Stock traders. Do you save up for the Bloomberg keyboard or do you rough it?

                      Don’t even try to get started on the various fine arts.

                      1. 1

                        I definitely know a musician who did a doctoral thesis on the acoustics of the material used in a single part of their instrument of choice.

                      1. 28

                        Rust’s style of borrow checking is a revolutionary idea because it makes practical things that were impossible before, outside of research languages. I don’t think that will go away any time soon.

                        Whether Rust itself is “the wave of the future” or not is still undecided, and frankly irrelevant. Maybe it is, or maybe it will become a Simula or SNOBOL that is mainly important for the ideas it pioneered and inspired in later languages. If I’m using something else as my main language in ten years it will be because it’s better than Rust. It’s a high bar, but certainly a conceivable one.

                        1. 27

                          I think Rust is way past the infancy stage, and is here to stay.

                          • Rust has a lot of momentum and is gaining popularity quickly. About 3 years ago number of Rust users and projects has surpassed Scala, D, Nim, and Haskell, and it’s way ahead them now, and growing. crates.io is growing faster than rubygems.org, and is already 40% of its size. Because of it’s niche Rust will never be as popular as mainstream GC languages, but it’s not an “alt-lang” anymore either.

                          • Rust has been explicitly designed as a practical language, not an experiment. It’s used in production. I know big companies where Rust is now a hard dependency for critical components, maintained by entire teams (not one dev’s side project any more).

                          • Rust is based on a lot of pre-existing research languages. In terms of rough syntax and post-ALGOL features there’s already some convergence between Rust, Kotlin, Swift, and TypeScript. The latter two are probably here to stay too, so they’ll keep Rust looking normal.

                          • In Rust’s niche of systems programming + safety there’s no competition. There’s lots of competition in easy GC languages, but that’s not Rust’s niche. There are other systems languages, some of which are nice, but without equal safety guarantees they don’t have the same hook that Rust has (e.g. Rust is getting into Linux because it’s safer, not because it’s nicer).

                          • There’s no obvious flaw (known yet) that a potential Rust-killer could address to displace Rust. New Rust users suffer learning the borrow checker, but it’s not a big issue for experienced users. Rust users are very satisfied with the language.

                          • Rust 1.0 has been released 6 years ago. Even if a Rust-killer was released tomorrow, Rust already has a significant head start and a track record. Rust is still being developed and evolving, so it can put up a fight by copying features from potential Rust-killers (and use the editions to delay ending up like C++).

                          Oops, my comment is longer than the article now :)

                          1. 15

                            Rust can still suffer from feature creep and long compilation times for large projects. These are things that takes a couple of years to see how they pan out.

                            1. 4

                              I think you’re probably right, I just also remember when Java was The Next Killer Thing and am not about to jump to any conclusions.

                              1. 17

                                Did that really end up being wrong? The initial imagined usecase for it (Applets) didn’t pan out, but a quarter of a century later it’s still the #5 programming language on Stackoverflow (really, number #3 if you accept that SQL and HTML/CSS aren’t so much competing with it as working in concert with it) and it’s probably still #1 in corporate circles.

                                It’s not my idea of a killer programming language, but the prediction that it was going to eat the world does seems to have largely bore out, just differently than the initial expectation.

                                1. 7

                                  And indeed java was the next big thing, look at how popular it is nowadays :-). It made garbage collection as mainstream as it could be.

                                2. 2

                                  In Rust’s niche of systems programming + safety there’s no competition

                                  You don’t hear much about it, but Ada has been in this space for 40 years.

                                  There’s no obvious flaw (known yet) that a potential Rust-killer could address to displace Rust

                                  Rust is good, but it has trouble enforcing large scale constraints on programs, which often show up in Real-Time systems, for which Ada was designed. For example, Ada’s Ravenscar profile detects behavior at compile-time in your program which will lead to unpredictable behavior in high-integrity applications.

                                  1. 4

                                    I deliberately haven’t mentioned Ada, because the metrics I have are biased towards open-source, and by these metrics Ada is dead.

                                    1. 3

                                      If your point is open source specific, you should say that, but deliberately ignoring a language because it historically been used for closed source systems is misleading.

                                      EDIT: I realized I probably came off as combative, which wasn’t my intent. I just don’t think those metrics capture really what’s happening since there’s a lot of closed source development. I just know for sure that OCaml is actively used for some companies critical systems but it doesn’t show up well on those metrics.

                                      1. 4

                                        I mean other langues have public package repositories and online communities, so they’re comparable this way. Ada isn’t, so I didn’t compare it.

                                        Back to the original point: the fact that Ada is used so differently — closer to DoD than GitHub – also means it’s not a direct Rust competitor. Rust’s openness, vendor-neutrality, community, and availability of open-source libraries are its assets too.

                                        1. 4

                                          means it’s not a direct Rust competitor. Rust’s openness, vendor-neutrality, community, and availability of open-source libraries are its assets too.

                                          Your point was that there was no safe systems programming equivalent to Rust, my point is that there is, it’s just not well known or used publicly. Ada may have originated from the DoD, but the major Ada implementation, GNAT and a lot of tooling and libraries are GPLv3 or a limited form with a runtime exception. I agree that there’s not really a well established Ada community and it’s just now providing a similar solution to Cargo or CPAN. There’s a lot more than you’d expect, but it’s sort of distributed right now (Ada Utility Library, GNATColl, GNAT, etc.) However, if people feel like they missed getting in on the ground floor of a major programming language and open source library development, there’s huge opportunity on a mature language available.

                                          I’m unsure how Rust has vendor-neutrality though when there’s only one main Rust implementation, whereas Ada is an ISO standard and has a full public battery of compiler tests for implementers.

                                          The DoD vs Github thing may have been true a few years ago, but there’s been a major push from the main Ada vendor, AdaCore, to split off and open source as much as possible, in a eerily similar way to what Mozilla has done (disclaimer: I’m not involved with AdaCore, so I don’t know how far this goes, or what their long term plan is).

                                    2. 1

                                      Can you tell me more about these large scale constraints? Are we talking like, latency/memory constraints?

                                      1. 3

                                        Just to give a few examples, there’s per-package (module) constraints like the Pure aspect, which ensures a module has no state and depends on none that has state. There’s also a pragma called “Restrictions” which can do various things like prohibit all or various types of dynamic allocation, prohibit floating point, prohibit the use of recursion, ensure no dependence on other specific modules of code, and so on.

                                        1. 1

                                          Those all sound like things that could be written as rustc lints. If an industry or organization had such requirements they could maintain lints that do exactly that, and enforce them via #[foo] attributes. Of course, there may be points I’m not thinking of that wouldn’t be possible as a lint as well.

                                          1. 2

                                            It really doesn’t sound like something that can be done with rustc lint. It sounds most similar to Safe Haskell to me. At the very least, cargo will be involved in addition to rustc.

                                  2. 5

                                    I 100% believe that Rust is the beginning of a new generation of programming languages. I don’t suspect that Rust will be popular in 10 years, but I’d be willing to bet money that there WILL be at least a few statically typed languages in 10 years that will have obvious roots in Rust.

                                    Don’t misunderstand my next sentence- I’m not saying that Rust invented anything. But, look at how many languages are implementing things like enums/ADTs and pattern matching “all of a sudden” (Python?! Are you for real?!). Look at Swift (which came out after Rust) looking to switch to a Rust-like lifetime/borrow mechanism. Look at ranges in C++.

                                    1. 8

                                      I think it’s likely that many languages will be influenced by Rust, since there are already dozens of such projects over at /r/ProgrammingLanguages and other places.

                                      But if there’s any one that will be popular in 10 years, it already exists now and you might have heard of it! That is, Rust itself took 8-9 years to become 1.0 and it’s existed for close to 15 years now! Languages just take a long time, so I think in 10 years Rust will still be the top choice … for people who want a “Rust-like” language :)

                                      I made a similar argument when someone was asking about alternatives to Matlab that are not Julia. If you haven’t heard of it already, it’s not likely you’ll be using it in production in 10 years!

                                      1. 6

                                        It is wild how long it takes the average language to gain mainstream popularity. For example, Python is one of the “new” hot languages of the last decade, but it is older than Linux!

                                        1. 2

                                          Python is a weird story, IMO. I don’t know anything about the language’s actual history, so my perception could be wrong. But I feel like it really just had a huge surge for some reason around 2005-2010-ish. I don’t exactly know what caused it or why it wasn’t very popular before then, but it’s really interesting that people just suddenly “discovered” it many years after it had been around. For a while, it seemed like everything was written in Python: desktop applications, CLI tools, server backends, data science code, etc.

                                          To be fair, the other viable languages for doing apps in 2005-ish were probably C++, Java, and whatever was in Microsoft land - C# I guess? I can see why Python would be appealing in that environment.

                                          1. 3

                                            I started using Python in 2003, and I agree it had a bump in popularity in the 2005-2010 era (although it still grew enormously in the last decade).

                                            I think it just takes that long to build a useful language – especially the libraries. I don’t think it was just “discovered” – the key is that it gained a lot of critical functionality.

                                            For example Travis Oliphant was beating the drum hard for NumPy and array programming in the 90’s and early 2000’s (writing a ton of code, documentation, explaining it at PyCon, etc.). And 10 or 15 years later that led to Pandas, Torch, Tensorflow, etc. which are a big part of why Python is popular now. (Ruby, JavaScript, PHP, and Perl all pretty much lack this functionality.)

                                            Guido had almost nothing to do with this! (although obviously he had his hand in so many other critical Python features)

                                            And I remember in 2005 or 2006, Python web programming was immature. I used CherryPy, and there was Twisted. It seems like the ecosystem has converged on Flask and Django to some extent. So it just took effort to build all of that. Ruby also seemed to lack web programming until Rails (afaik).

                                            In 2003, the meme was that Python was a cleaner Perl, but it lacked libraries. People said Perl was a better choice because it had CPAN. Fast forward a few years and now everyone talks about how Python has more bindings for libraries than say Go or Rust! It just takes time.

                                            1. 2

                                              Thanks for the insight. As I said, I was kind of passive observer, as I was just barely learning to program in 2007-ish.

                                          2. 1

                                            Yup, Python and Ruby are of a similar vintage, and they both took more than a decade before getting popular. I hadn’t heard of Python before 2003, and it started in 1990 or so. I agree it had a big bump in popularity in the 2005-2010 era.

                                            I think it just takes that long to make a useful language.

                                            JavaScript was arguably not very popular before 2005 or so, about a decade after its creation. And it really got popular in 2009 with node.js.

                                            Ditto for R – it started in 1995, and I started using it in 2009 or so, and a lot of people still haven’t heard of it.

                                            PHP and Perl seem to have gotten fairly popular out of the gate. It would be interesting to know why that is. I think one reason is that PHP was basically a bunch of libraries at first, and not a programming language! It was tightly coupled to Apache, which was becoming huge because people wanted an open source web server.

                                          3. 1

                                            Yes, that’s a good point, of course. The probability of a language surviving increases as it continues to survive. That sounds almost tautological, but it isn’t.

                                          4. 3

                                            I don’t suspect that Rust will be popular in 10 years

                                            Out of interest, why do you say this? Is there a specific reason/reasons why you think its popularity will plateau/wane?

                                            1. 3

                                              It’s mostly a hunch, but there are a couple of half-baked reasons:

                                              • Statistically speaking, it’s just a safe bet, because there are tons of languages at any given time, but only a few that have lived and thrived for 20+ years (probably single-digits: C, C++, Java, Python, PHP, C#, JavaScript… that’s it? Unless you count LISP, Fortran, Haskell, and Perl as “living and thriving” which I don’t).
                                              • Error handling. I mostly like Rust’s error handling mechanism, but I suspect that it’s too tedious for most people and I think there’s room for languages to try other things that may end up being better. Tangentially, my controversial opinion is that checked exceptions deserve another attempt besides how they were implemented by Java. Rust’s approach would be improved (ergonomically) by either ad-hoc enum types or actual inheritance.
                                              • Async and Futures, etc. I have a feeling that async/await syntax is a fad for this decade-ish and that in 10 years we’ll all think it was sooo stupid and that “concurrency hoobajoobs” is clearly the right way to do concurrency/async. I don’t have any particular complaint about async, colored functions, Futures, etc- I just see that it’s been very cargo-culty across the entire programming language ecosystem- very similar to OOP in the 90s and similar to FP and monad-all-the-things today.
                                              • I also have a hunch that structural typing will become more popular for statically typed languages. That may or may not affect Rust depending on how soon that happens and how cemented Rust is in particular niches.
                                              1. 2

                                                Not GP, but I think other languages could improve upon Rust.

                                                C identified the high-level patterns that assembly programmers were using: if statements, loops… and it gave us constructs to speak in those higher-level terms.

                                                I think a language could identify the common patterns that Rust programmers often use, and then offer those more directly, with less complexity.

                                                Some other promising avenues: https://cone.jondgoodwin.com/ is making borrow checking easier by complementing it with other memory management strategies, and http://strlen.com/lobster/ is pushing static analysis to be near the borrow checker’s speed.

                                                1. 15

                                                  Replacing languages is an infrequent event. Programming languages are very often invented and designed, but mustering the resources to bring a language of the scope of Rust to industry adoption is really hard and needs a lot of dedication and sweat.

                                                  Programming languages are very hard to argue for, spending-wise. And given that Rust is one of the only languages currently being adopted by all the major companies, they will think hard about the delta that languages following it will bring.

                                                  1. 2

                                                    I could agree with your phrasing of “adopted by all the major companies”, though I might have phrased it like “adopted by some parts of a lot of major companies, for some things”.

                                                    I’m probably speaking from my own bubble, but I don’t really see that Rust has taken off yet. In my day to day job, I see these very clear trends: Obj-C to Swift, Java to Kotlin, Javascript to Typescript. For most actively developed projects where I work, that migration is either underway or in the plans. But I’m not seeing the C++ to Rust transition I would have hoped for. It’s not really even considered that seriously.

                                                    From experience, I can only guess that, while Rust is perfect on paper, its difficult learning curve and complexity is what’s holding it back. With that in mind, I wouldn’t be surprised if Rust keeps growing but some other systems language surpasses it in a decade or so, probably one that has the safety and speed of Rust but without the complexities.

                                                  2. 4

                                                    C didn’t come into a world where everyone was writing in assembly; its creators had already been involved in Multics, which was programmed in PL/1, for instance. Burroughs had been using ALGOL as its systems language, as had many others, etc.

                                              2. 6

                                                Ada has had accessibility checks since 1995, through it’s system of making its pointer-like types into actual types which depend on the lifetime in which they’re declared.

                                                1. 4

                                                  I really have to check Ada out, even if only for the historical context. I keep hearing all kinds of interesting things about it. The cynic in me feels like there must be a huge catch, like it must have something that just makes it horrible to work with…

                                                  1. 12

                                                    The catch is verbosity due to no macros or preprocessor, and then eventually you figure out that verbosity is a signal from the language that you’re going about your problem in the wrong way.

                                                    In general it feels like finding a old but super advanced spaceship crashed in your yard that works just fine, but if you tell anyone you’re using it they think you’re just crazy.

                                                    1. 2

                                                      What’s the concurrency story like?

                                                      (Yes I keep popping up on your comments and no I still haven’t managed to really crack ada open. Maybe I should, and should look at how to link it to other stuff with more active library communities)

                                                      1. 5

                                                        Built into the language you have “protected objects” which provide mutual exclusion to shared resources, and “tasks” which provide the ability to spin off work. You coordinate (rendezvous) with a task by calling one of its “entries”, which are sort of like a procedure call version of “await aTask.asyncFunction();” but “protected objects” can also add guards to these to cause a task to wait in a queue until specific conditions are fulfilled.

                                                        Queueing is handled by the language, and as part of these features is a construct called “select” which lets a task “accept” one of multiple entries another flow of execution is waiting on. Since this is built into the language, you also get time-outs waiting on conditions for free, as well as a form of select which will execute a different flow if an entry on a task or protected object would block or if one of the flows exceeds a time limit, like it a calculation takes too long.

                                                        What’s super helpful is that because Ada features are opt-in rather than opt-out, you can ignore tasks and protected objects until you understand more of the language, and then define tasks within your functions to split work later on.

                                                        active library communities

                                                        You can get super far with just the standard library defined by Ada itself, and also the freely available GNAT and GNATCOLL libraries.

                                                        1. 2

                                                          That’s cool. It sounds kind of like an actor model, and should be easy to build the necessary functionality on top if one wanted “proper” actors.

                                              1. 6

                                                Some of you are predicting rust will spawn languages that replace it, here is one I am interested in: https://vale.dev/

                                                Some comments are speculating on longevity. My prediction is that rust is java. It’s cumbersome, monolithic, “safe”, does the job and industrial in flavor.

                                                By the time the first three points of my enumeration become true (i.e. lighter, clearer things show up) it’ll be so rooted that it’ll take the henchman role from java.

                                                1. 9

                                                  Some comments are speculating on longevity. My prediction is that rust is java. It’s cumbersome, monolithic, “safe”, does the job and industrial in flavor.

                                                  I regularly burn a lot of karma on /r/rust with that viewpoint and have absolutely no problem with that :).

                                                  Both Rust and Java are deliberately built with large codebases in mind, which might make them see cumbersome on smaller ones.

                                                  1. 2

                                                    Hrm. What’s their plan for addressing the iron triangle of fast/cheap/good? It sounds like they want to offer all three even though their core offering - a generational reference memory management system - is still only a hypothetical. Am I missing something?

                                                    1. 1

                                                      It’s an interesting but incomplete project for these exact reasons. The website is a great resource.

                                                  1. 4

                                                    As hinted in the text, its the same people as behind the Rust Belt Project. http://plv.mpi-sws.org/rustbelt/

                                                    1. 1

                                                      Some of them. Kayvan was also one of the people driving the Cerberus work.

                                                    1. 2

                                                      Tangential, but: I had a very interesting chat with some of the people behind the framework mentioned here - Nannou - (https://mindbuffer.net) a couple of years ago and when I expressed that I’m a little puzzled why they use Rust for this, because Rusts focus on stability/correctness <> artistic free expression felt a little odd. Their answer was pretty interesting: they build installations for museums all around the globe. Once the installation is finished, it gets sent around the globe to be presented for months in constant use. Repairing problems becomes really expensive, especially as there’s often no second “reference” build. So everything that helps them not have any problems that need debugging across half the globe is very useful for them.

                                                      It’s interesting how technologies focused on certain aspects of stability are used in art: e.g. also SonicPi famously as an Erlang/OTP core.

                                                      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?

                                                                      1. 1
                                                                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. 12

                                                                      I agree that Ada is very much benefiting from the recent new interest in systems programming. A tag sounds reasonable.

                                                                      1. 5

                                                                        …Ada is very much benefiting from the recent new interest in systems programming.

                                                                        This is fantastic point, thanks for making it. My personal impression has been exactly this, and it’s identifiable as such now that you’ve articulated it with clarity. Hopefully the heritage of Ada will continue to have a positive influence even as Ada itself continues to grow and thrive.

                                                                        1. 2

                                                                          recent new interest in systems programming

                                                                          In what sense is it “recent”? But yes, a tag would be good.

                                                                          1. 5

                                                                            There’s a new wave of systems programming languages in the last 5-10 years: go as a starter, but then Swift, Rust, nim, zig and such, all serious contenders in that space. Before that, systems programming was the thing you do if you must for a while, now, it’s becoming a much stronger thing.

                                                                            Before that happened, there was no way past C or C++, but now there’s a space where people actually consider switching away from those. I know of at least one place where that evaluation was actually “Ada vs. Rust” and that speaks to how Ada doing well in that situation.

                                                                            Essentially: Rust makes people remember Ada.

                                                                        1. 2

                                                                          I’m normally impressed by the Rust team, but from my position of ignorance this seems like a surprisingly bad solution to this problem. It sounds like at least some people were planning the whole time to release 1.52 without fixing the bugs that were exposed by this check (just, without the check in place). Maybe they didn’t know about the miscompilation?

                                                                          The chosen solution, to totally disable a feature that’s crucial for usability, seems pretty extreme - surely there are less extreme workarounds? e.g. you could presumably simply clean the cache when you see this error.

                                                                          I do really appreciate the helpfulness of this blog post in describing the problem, and I’m probably missing some important details that make this the best way to deal with the situation.

                                                                          1. 21

                                                                            Rust is a lot about correctness, and we’d rather prefer to keep such a critical feature off rather than having it broken. We didn’t know about this bug until last Thursday and it’s actually present in versions before Rust 1.52.0.

                                                                            Even if rare and sporadic, this is most likely an old bug. This means that the recommendation for all users is to disable incremental compilation, even on older Rust versions if they want to make sure they don’t hit this bug.

                                                                            The new version was released to avoid users from downgrading to avoid the ICE, which would just hide a miscompilation - leading potentially to other problems that we would need to trace down to this bug.

                                                                            Incremental compilation also isn’t quite as crucial in Rust: it only happens on a per-crate level, so it’s not like you need to rebuild everything. It’s annoying, but this gives us time to write a proper fix.

                                                                            I would expect a 1.52.2 soon once engineers had a good look at this issue and validated solutions.

                                                                            1. 2

                                                                              surely there are less extreme workarounds?

                                                                              Add RUSTC_FORCE_INCREMENTAL=1 to your .profile and move on ? Hopefully you don’t ship anything critical this way. The new default just prevents any kind of miscompilations by giving you the safe route by default. That way nothing goes sideways at some possibly critical application due to a known bug. Which might do real world damage.

                                                                            1. 2

                                                                              Slightly unfortunately named: https://github.com/jordansissel/fpm

                                                                                1. 2

                                                                                  I you ask me, “Fortran” seems more intuitive than “Effing”.

                                                                                1. 31

                                                                                  If the author is here and open to changing the post title, Rust is for everyone, and good for professionals too! The title as is sounds like it may be exclusionary toward people who don’t identity as professionals, or feel intimidated by Rust, which is contrary to Rust’s core goal of opening up systems programming to everyone!

                                                                                  1. 39

                                                                                    I, the author, am here.

                                                                                    I appreciate the constructive feedback and can see your point. Choosing titles is hard. I too was concerned about the exclusionary potential for the title. However, I thought I had it sufficiently mitigated by the introduction paragraphs. Apparently I could have done better.

                                                                                    I’m not going to change the title of this post because I don’t want to deal with the hassle of rewriting URLs. However, I will try to consider your feedback for future posts I author.

                                                                                    1. 6

                                                                                      I appreciated the way you took the feedback. Just wanted to say thanks for listening and considering it.

                                                                                      1. 3

                                                                                        I’ve programmed in the following languages: C, C++ (only until C++11), C#, Erlang, Go, JavaScript, Java, Lua, Perl, PHP, Python, Ruby, Rust, shell, SQL, and Verilog.

                                                                                        To me, Rust introduced a number of new concepts, like match for control flow, enums as algebraic types, the borrow checker, the Option and Result types/enums and more.

                                                                                        How did you use Erlang without pattern matching?

                                                                                        1. 2

                                                                                          I think the order is alphabetical so its possible that author used Erlang after he learned Rust.

                                                                                          Have a nice day!

                                                                                          1. 1

                                                                                            Doesn’t add up, he says that Rust introduced pattern matching to him :-)

                                                                                        2. 3

                                                                                          My usual way of framing it is “Rust is an industrial programming language”. That leaves the door open for practitioners of all kinds. It’s more like a cars are (in general) a utility and not a plaything or research endeavor, but are open to enthusiasts and amateur practitioners as well.

                                                                                          1. 2

                                                                                            Thanks! I liked the disclaimer, and think predicting how people will respond can be tough. Appreciate you putting in the time to write this, and agree that Rust can be used in professional / production environments successfully, and that it can feel like a breath of fresh air for many!

                                                                                          2. 22

                                                                                            Or, alternately, when someone writes 13,000 words about how nice Rust is, how ergonomic and human-centric and welcoming and humane the language and tooling and community are, they can keep the title without someone telling them they’re maybe being exclusionary.

                                                                                            1. 16

                                                                                              It’s constructive criticism. If you post something on the public web, it’s fair game to criticize it- especially if done in a polite manner.

                                                                                              1. 23

                                                                                                It’s criticism, but just because it’s delivered politely does not mean it is constructive. There is a cost to spending the effort to write a thirteen thousand word love letter to a language, just to have someone nipping at your ankles about how the first four words might exclude someone. Objectively speaking, this is a blogger that Rust would benefit from sticking around – but what is the signal they’ve received here?

                                                                                                1. 11

                                                                                                  Agree 💯.

                                                                                                  Recently a friend submitted his static site generator which is optimised for math heavy sites on HN.

                                                                                                  He made the fatal mistake of calling it “beautiful” in the description and the amount of hangups that people had. It was done in a mostly polite manner, but the amount of time and energy wasted in discussing just the first sentence with barely any technical discussion of the internals, was a form of pathological bikeshedding that I was surprised to see. It was just that “nipping at his ankles” as you’ve described, which can take its toll.

                                                                                                  Vowed to never take that site seriously again.

                                                                                                  1. 1

                                                                                                    It was done in a mostly polite manner, but the amount of time and energy wasted in discussing just the first sentence with barely any technical discussion of the internals, was a form of pathological bikeshedding that I was surprised to see. It was just that “nipping at his ankles” as you’ve described, which can take its toll.

                                                                                                    Agreed. Yet here we are- arguing about arguing. I need a life… xD

                                                                                                    1. 1

                                                                                                      Right, in my experience, HN often attracts uninteresting, unhelpful, or even mean-spirited commentary. Sometimes I am surprised by the opposite, though. In any case, understanding the dynamic really helps. A lot of commentary, seems to me, are upset at some level in some way and take it out in their commentary.

                                                                                                    2. 3

                                                                                                      The author thanked them and described the feedback as constructive. So if they feel like they’ve taken something away from it, who are we to decide otherwise? My own hopefully constructive feedback here is that this subthread strikes me as projecting conflict into an interaction between two parties who themselves seem to have had a positive experience with it.

                                                                                                      1. 2

                                                                                                        Yeah, I get where you’re coming from and I don’t really disagree.

                                                                                                        But I also think that the person who offered the criticism is just trying to help the author get more views.

                                                                                                        It’s fair to suggest that we all should consider our criticisms carefully, though. Because you’re right- if the criticism isn’t that important, we may just be disincentivizing someone from future contributions.

                                                                                                        I also wonder if you’re maybe reading a little too hard into the choice of the word “exclude” used by the criticizer, though… I think that term has a little bit of extra charge and connotation in today’s social environment and I don’t believe the criticizer meant it in that way. I think they simply meant that a person who isn’t writing enterprise software might pass over the article because they believe they aren’t the target audience. I agree with that conclusion as well, because I do write enterprisey software and I thought the article was going to be about that specific point of view- I thought I would see arguments about productivity and developer costs and cross-platform support and other less-sexy stuff. But, it was really- as you said, just a love letter to everything about Rust.

                                                                                                    3. 8

                                                                                                      I felt this lead-in made it a friendly suggestion and not harsh:

                                                                                                      If the author is here and open to changing the post title

                                                                                                      1. 4

                                                                                                        FWIW first third of those thousands of words is irellevant chitchat. The First actual claim on why is rust good is rust makes me giddy. I’m not sure “giddy” describes profesionals. It’s not no, but for me definitely not a yes either - giddy is just…giddy. Then all the technical points, borrow checkers, race conditions and whatnot - none of that tells me why is it a thing for professionals.

                                                                                                        What I mean is, I don’t know if rust is for pros or not, I just think that the title is a bit click-baity, and “rust is good for everyone, even pros” like alilleybrinker suggested would work much better.

                                                                                                        1. 7

                                                                                                          The First actual claim on why is rust good is rust makes me giddy. I’m not sure “giddy” describes profesionals.

                                                                                                          There’s a layer of extra irony here in that the word “amateur” comes from a root meaning “love”; in other words, amateurs are people who do something because they love it. So taken literally, this is very unprofessional!

                                                                                                      2. 18

                                                                                                        It seems relevant to note that the author does address this in the post itself:

                                                                                                        The statement Rust is for Professionals does not imply any logical variant thereof. e.g. I am not implying Rust is not for non-professionals. Rather, the subject/thesis merely defines the audience I want to speak to: people who spend a lot of time authoring, maintaining, and supporting software and are invested in its longer-term outcomes.

                                                                                                        1. 10

                                                                                                          Yes, except the title doesn’t have a disclaimer, and will be taken in the way they say they don’t want. Rather than leaving it ambiguous, they could change the title to remove the ambiguity.

                                                                                                          1. 28

                                                                                                            This side-steps the issue “people don’t read past the title” - which is the real problem. It’s bad, and unrealistic, to expect every person who writes on the internet to tailor each individual sub-part of an article (including the title) to an audience that is refusing to read the (whole) article itself before making judgements or assumptions. That’s purely the fault of the audience, not the writer, and changing the article title is merely addressing the symptoms, instead of the root problem, which will allow it to just become worse.

                                                                                                            We have an expression “judging a book by its cover” specifically for this scenario, and in addition to that, any reasonably-thoughtful reader is aware that, once a sufficient amount of context has been stripped away, any statement loses its meaning - which logically implies that full context must be absorbed before the reader has any chance of understanding the author’s intended meaning.

                                                                                                            People should not have to write hyper-defensively on the internet, or anywhere, because civil discussion collapses when your audience isn’t acting honestly.

                                                                                                            Reading the title and judging before reading the content itself is not acting honestly.

                                                                                                            1. 4

                                                                                                              Thank you for writing this. I’m sick of how much culture is warped by toxic social media sites.

                                                                                                            2. 7

                                                                                                              Agreed. It’s a poor choice for a title, even with a disclaimer. In fact, that he knew he needed a disclaimer should have been a big clue that it wasn’t a good title.

                                                                                                              A better title would be: “Professional devs should love Rust”, or “Rust isn’t just for enthusiasts and hipsters”

                                                                                                              1. 0

                                                                                                                I don’t disagree.

                                                                                                            3. 18

                                                                                                              Responses like this make me hesitant to try Rust, because they make me feel that I’d have to tiptoe around every word I put into a chat room, issue tracker, or mailing list.

                                                                                                              1. 10

                                                                                                                I’m not sure this is a Rust issue as much as a general issue of recent years. Be delicate and excessively sensitive about everything because everyone’s an egg shell. It’s contrary to anti-fragility which I would suggest is a far better approach; and the opposite approach. “Rust is for professionals” would have had me targeting Rust so that I could level up, not scare me away. Show me a challenge,

                                                                                                              2. 5

                                                                                                                I used rust for three years outside of work, but I’m afraid I stopped last year because I find it too big for a hobbyist. If I used it all day every day - no problem. It’s a great language, but I agree with the title.

                                                                                                                1. 2

                                                                                                                  This was my first thought, as well, before even reading the article. Obviously I should read before judging, but the author may want to consider that the title could turn away potential readers.

                                                                                                                  I made the same mistake in my own My staff engineering reading list. There was no reason for me to needlessly exclude people earlier in their careers from my list.

                                                                                                                  And it’s good feedback that the author of this piece may not want to unintentionally exclude people from their article.

                                                                                                                1. -10

                                                                                                                  Looks ugly.

                                                                                                                  1. 3
                                                                                                                    1. -2

                                                                                                                      Nice to know. 👍🏻

                                                                                                                    2. 2

                                                                                                                      I’m sure the author would appreciate more constructive criticism :)

                                                                                                                      1. -2

                                                                                                                        Add paddings.

                                                                                                                      2. 1

                                                                                                                        It works really well on mobile.

                                                                                                                        1. -4

                                                                                                                          Not really.

                                                                                                                      1. 1

                                                                                                                        I totally expect that the new tokens are not accepted by many tools because they did simple regex matches to pre-validate the tokens.

                                                                                                                        1. 1

                                                                                                                          Yep, but it has to be said that GitHub has been sending out emails to everyone who requests tokens in the old format for roundabout a year. Around every month or so, you get a “please update your software”.

                                                                                                                          1. 3

                                                                                                                            For manual created tokens I only get them since they releases the blog post yesterday.

                                                                                                                        1. 8

                                                                                                                          Hm, so, as someone who literally did language evangelism for quite a while now (Ruby and Rust for over a decade): I’d stick with python and maybe use something current like modern Django or one of the smaller frameworks. If you really want some fresh air, maybe switch to a language close to it, like Ruby or even PHP (with all its bad rep, there’s a reason PHP is still the dominant language).

                                                                                                                          Given that you don’t want to maintain the old code, trying out a new ecosystem on your know problem will almost surely yield the next code base that you don’t want to continue to maintain - especially if the ecosystem is far out.

                                                                                                                          Also, given that it sounds like the app has a web part, I’d avoid all things Rust. Not because I don’t like it, but there’s not stable web frameworks and their general security/templating stack is very diverging/incomplete (e.g. things like safe cookie handling, CSRF, XSS, and such). So you either forgo the whole problem or you have a lot of things to investigate. APIs, I’m less hesitant, but for the rest, the story is still very spotty.

                                                                                                                          That all being said, taking slices from your problem and reimplementing it in languages you want to try is a very useful method of learning, but I’d prepare myself for throwing the code away. Detaching learning from necessary success also makes the thing far more relaxing.

                                                                                                                          1. 2

                                                                                                                            given that it sounds like the app has a web part, I’d avoid all things Rust […] the story is still very spotty

                                                                                                                            Completely agree, sadly. Recently I poked around the Rust web landscape looking for a web framework with one simple criterion: uses up to date dependencies. I couldn’t find anything that actually uses the latest version of hyper besides warp, which isn’t a framework so much as an HTTP server toolkit.

                                                                                                                            And the most downloaded framework on crates.io, Iron, is essentially unmaintained at this point.

                                                                                                                            The Rust web ecosystem is growing fast, with tons of promising work. But it’s not mature by any stretch of the imagination.

                                                                                                                          1. 4

                                                                                                                            Having &str, Str and [u8] in obviously necessary, but surprises a newcomer.

                                                                                                                            Aye. Rust has &str, String, [u8] (and &[u8]), OsStr, OsString, CStr, CString, 7 different types of string. It’s not nearly as bad as Win32 development, where there are literally dozens of string types, but it still confused the heck outta me when I first tried Rust.

                                                                                                                            1. 3

                                                                                                                              I found the variety of Rust string types fairly straightforward. They’re for different things. Easy.

                                                                                                                              However, &str itself did confuse me quite a bit. I kept thinking if you always use &str, what is plain str anyway? It took some significant pondering to wrap my head around whole idea of a magical type of undefined size—essentially [u8; ?] where the compiler knows the length ? for static strings. And I’m not even sure that’s correct. As my mental model it has held up so far, but I still don’t really know.

                                                                                                                              1. 4

                                                                                                                                Yeah, str is ‘unsized’. The Rust Language Cheat Sheet might help provide a visual idea of how these are laid out:

                                                                                                                                1. 1

                                                                                                                                  Wow this is a great resource, thank you!

                                                                                                                                2. 2

                                                                                                                                  I wrote a little about this a while back on reddit: https://old.reddit.com/r/rust/comments/gnd4bd/things_i_hate_about_rust/fr9179w/

                                                                                                                                  Apologies if you aren’t quite the target audience. It’s likely I said a lot of things that you already know. :-)

                                                                                                                                  1. 1

                                                                                                                                    This is great! It confirms my mental model about str and &str.

                                                                                                                                    Although I don’t understand this part:

                                                                                                                                    AsRef::as_ref is &T, so calling as_ref on something that implements AsRef<str> gives you a &str

                                                                                                                                    How does as_ref get ptr+len from a pointer to str? The source for impl AsRef<str> for str isn’t exactly illuminating. I think this is the same question as my question here.

                                                                                                                                    My best guess is Box<T> is a special compiler-implemented type that has an in-memory representation of &T, and thus actually does include ptr+len for Box<str>. This seems to indicate so:

                                                                                                                                    println!("{}", std::mem::size_of::<Box<u8>>());
                                                                                                                                    println!("{}", std::mem::size_of::<Box<str>>());
                                                                                                                                    // 8
                                                                                                                                    // 16
                                                                                                                                    
                                                                                                                                    1. 2

                                                                                                                                      How does as_ref get ptr+len from a pointer to str? The source for impl AsRef for str isn’t exactly illuminating. I think this is the same question as my question here.

                                                                                                                                      Hah. Yeah, in the source for the AsRef<str> for str impl, self has type &str. That’s kind of the trick that dynamically sized types enable. That is, that you can impl traits on a T that does not have a sized known at compile time. In cases like that, you wouldn’t be able to write fn foo(self) since self wouldn’t have a known size. But in fn foo(&self), since self has type &T, it is guaranteed to have a known size.

                                                                                                                                      My best guess is Box is a special compiler-implemented type that has an in-memory representation of &T

                                                                                                                                      I think there are special things about Box, but this actually isn’t one of them. The same is true for Arc and Rc for example. Both of those types can be implemented in pure library code. I don’t believe there are any special things in the language that make it work. The key is that Rc (and similar types) are defined with a T: ?Sized bound, which means T doesn’t have to be sized.

                                                                                                                                      Following the breadcrumbs here a bit might help. An Rc’s internal implementation is actually an RcBox. Its definition is this:

                                                                                                                                      struct RcBox<T: ?Sized> {
                                                                                                                                          strong: Cell<usize>,
                                                                                                                                          weak: Cell<usize>,
                                                                                                                                          value: T,
                                                                                                                                      }
                                                                                                                                      

                                                                                                                                      That’s something anyone can define: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=8ad24efeaaa015958abaf338f5100663

                                                                                                                                      The key here is that T does not have a known size at compile time. This actually imposes restrictions on the definition of the struct itself. For example, if you changed its definition to

                                                                                                                                      struct RcBox<T: ?Sized> {
                                                                                                                                          strong: Cell<usize>,
                                                                                                                                          value: T,
                                                                                                                                          weak: Cell<usize>,
                                                                                                                                      }
                                                                                                                                      

                                                                                                                                      then it would not compile because the compiler doesn’t know the size of T and thus the offset of weak is unknown. AIUI, this is all pretty similar to C’s “flexible array member” feature, and it to has to be the last field in a struct.

                                                                                                                                      Stepping up a bit, it might be instructive to follow the trait for how a String gets converted to a &str:

                                                                                                                                      • You might start at String::as_str, but it just returns self, where the type of self is a &String. The trick here is knowing that String impls Deref, so a &String automatically coerces to a &str. But… how is Deref itself implemented?
                                                                                                                                      • The Deref impl just calls std::str::from_utf8_unchecked with &self.vec, where the type of &self.vec is &Vec<u8>. But the type of the parameter for from_utf8_unchecked is &[u8]. So it looks like we need to go find the Deref impl for &Vec<u8>.
                                                                                                                                      • Briefly, we note that the impl of from_utf8_unchecked is a transmute from &[u8] to &str. This is safe because they have the exact same layout in memory. Thus, if we learn how to get a &[u8], then we will have solved this riddle.
                                                                                                                                      • The Deref impl for Vec defers to slice::from_raw_parts. Crucially, this is the point at which the size information is made explicit. Namely, from_raw_parts is called with two arguments: the pointer to the underlying memory and the length of that memory.
                                                                                                                                      • The slice::from_raw_parts impl defers to ptr::slice_from_raw_parts.
                                                                                                                                      • And finally, the impl of ptr::slice_from_raw_parts shows the explicit representation of a &[u8] in memory:
                                                                                                                                      pub const fn slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] {
                                                                                                                                          // SAFETY: Accessing the value from the `Repr` union is safe since *const [T]
                                                                                                                                          // and FatPtr have the same memory layouts. Only std can make this
                                                                                                                                          // guarantee.
                                                                                                                                          unsafe { Repr { raw: FatPtr { data, len } }.rust }
                                                                                                                                      }
                                                                                                                                      

                                                                                                                                      And how is Repr defined?

                                                                                                                                      #[repr(C)]
                                                                                                                                      pub(crate) union Repr<T> {
                                                                                                                                          pub(crate) rust: *const [T],
                                                                                                                                          rust_mut: *mut [T],
                                                                                                                                          pub(crate) raw: FatPtr<T>,
                                                                                                                                      }
                                                                                                                                      
                                                                                                                                      #[repr(C)]
                                                                                                                                      pub(crate) struct FatPtr<T> {
                                                                                                                                          data: *const T,
                                                                                                                                          pub(crate) len: usize,
                                                                                                                                      }
                                                                                                                                      

                                                                                                                                      The main compiler magic here I think is just that the representation of &[u8] is defined to be Repr as above. And from there, you can type pun to any one of the equivalent representations.

                                                                                                                                      The other piece of compiler magic here is dynamically sized types as well. The same thing that makes Box<str> work is the same thing that makes Rc<str> or Arc<str> or even your own type. So it’s not specific to Box<str>. And yup, Rc<str> also has a size of two words just like Box<str>.

                                                                                                                                  2. 2

                                                                                                                                    Plain str is useful as there’s also things like Box<str>, Rc<str> and Arc<str>(which are heap-allocated, but non-growable strings, but the first is uniquely owned and the second is immutably shared).

                                                                                                                                    1. 1

                                                                                                                                      I actually didn’t know that, as I’ve always just used String. Neat!

                                                                                                                                      In that case, how does this example work?

                                                                                                                                      let boxed: Box<str> = Box::from("hello");
                                                                                                                                      println!("{}", boxed);
                                                                                                                                      

                                                                                                                                      Shouldn’t the length of the str “hello” in boxed be unknown?

                                                                                                                                      1. 2

                                                                                                                                        In this case, the type of "hello" is actually &'static str. It’s a constant, so the compiler can construct it as a string literal with its size. Calling Box::from("hello") will actually copy the data into a fresh allocation created by the Box. Indeed, it will do this for all &str values because its from impl is only defined for &str.

                                                                                                                                        A more interesting case is getting from a String to a Box<str> without allocating or copying. In that case, the underlying allocation is simply reused.

                                                                                                                                    2. 1

                                                                                                                                      Yeah, I’d say that they’re fundamentally different objects. In particular, I wouldn’t say that [u8] is a string, it’s a contiguous region of bytes. Calling that a string is like calling [u8; 8] a double.

                                                                                                                                      1. 1

                                                                                                                                        Right, but str doesn’t have a + operator like a double. It has a [] slice operator like an array. And it slices bytewise, not by character. While str and [u8] are conceptually and semantically different—str must be UTF-8—they’re still alike in more ways than [u8; 8] and double.

                                                                                                                                        1. 1

                                                                                                                                          str does not have a slice operator, because indexing into UTF-8 is very ambiguous.

                                                                                                                                          You can go from str to [u8] through, but not the other way around.

                                                                                                                                          1. 2

                                                                                                                                            str does not have a slice operator

                                                                                                                                            That might be confusing for folks I think. &s[start..end] is a “slicing operation” in my head at least. I guess I would say, “str cannot be indexed by a single offset, but a substring can be extracted by slicing at offsets at valid UTF-8 boundaries.” A bit longer winded I guess.

                                                                                                                                            As to this:

                                                                                                                                            While str and [u8] are conceptually and semantically different—str must be UTF-8—they’re still alike in more ways than [u8; 8] and double.

                                                                                                                                            I’d say… probably that’s true. But it’s kind of hand wavy and it depends on how you look at it.

                                                                                                                                            1. 1

                                                                                                                                              For sure hand wavy. I guess what meant was:

                                                                                                                                              let d = 1.0;
                                                                                                                                              let a = [u8; 8];
                                                                                                                                              let s = "string";
                                                                                                                                              

                                                                                                                                              The operations you can perform on a and s are more similar than the operations you can perform on a and d.

                                                                                                                                              str does not have a slice operator

                                                                                                                                              @skade is this not slicing? impl<I> Index<I> for str, impl SliceIndex<str> for Range<usize>.

                                                                                                                                              because indexing into UTF-8 is very ambiguous

                                                                                                                                              Slicing—or whatever it is—into UTF-8 is possible, but doing so incorrectly will panic:

                                                                                                                                              fn main() {
                                                                                                                                                  // utf-8 char at s[1..3]
                                                                                                                                                  let s = "héllo";
                                                                                                                                                  
                                                                                                                                                  // "hé"
                                                                                                                                                  println!("slicing utf-8 at valid boundary: {}", &s[..3]);
                                                                                                                                                  
                                                                                                                                                  // panics: byte index 2 is not a char boundary
                                                                                                                                                  println!("slicing utf-8 at invalid boundary: {}", &s[..2])
                                                                                                                                              }
                                                                                                                                              

                                                                                                                                              Rust playground link for above code.

                                                                                                                                              1. 3

                                                                                                                                                I think what @skade meamt is that you can’t do s[i]. Wording looks confusing to me though.

                                                                                                                                  1. 50

                                                                                                                                    A thought I’ve seen from several people: if a movement is as dependent on the constant personal presence and involvement of one of its founders as the Free Software movement is alleged to be dependent on Stallman, is that really a sign that the movement is healthy and strong? If it just can’t possibly get along without him occupying high leadership positions, well, the dude’s not getting any younger. Is there even a future for the FSF and the Free Software movement when simple human mortality eventually catches up to him?

                                                                                                                                    1. 54

                                                                                                                                      if a movement is as dependent on the constant personal presence and involvement of one of its founders as the Free Software movement is alleged to be dependent on Stallman

                                                                                                                                      I don’t think it is. In fact, I think Stallman’s involvement is holding the movement back, and has for many decades.

                                                                                                                                      1. 9

                                                                                                                                        I wonder how much of this was nobody being willing to tell him to his fact that he’s an embarrassment and an anachronism and that he should take some time away to enjoy retirement and consider his life choices.

                                                                                                                                        This is 2021. I have a ton of empathy for social mal-adjustment. In many ways I still suffer from that myself but have had the benefit of some amazing people around me who’ve helped me grow past some of the worst of it, BUT this isn’t just his hobby project anymore.

                                                                                                                                        Free software represents the beating heart of some truly mission critical pieces of infrastructure in modern society. I maintain that if he truly cared about the cause more than feeding his own ego he’d have stayed on the sidelines.

                                                                                                                                        1. 6

                                                                                                                                          As do I, but for some reason a lot of people seem to think that RMS is too important and can never be removed or retired.

                                                                                                                                          1. 26

                                                                                                                                            I think that a lot of people are hung up over the reasons Stallman got removed. You can argue, quite reasonably, that he should have been removed for those particular comments about Minsky and such. Opinions will undoubtedly differ over this, and that’s okay. But … that’s not really what happened: people made those comments seem much worse than they actually were by removing the context and interpreting them as if they were made in the most bad-faith way possible, and several major newspapers ran headlines that were, quite frankly, just misleading and downright wrong.

                                                                                                                                            If we get in to an argument at the pub and I shove you out of anger then I’m clearly in the wrong, but if you go around telling people I beat you up then that’s not exactly fair.

                                                                                                                                            It would have been much better if we had a much broader discourse about whether Stallman is a good leader (he’s not) where this particular issue was just a part the discussion surrounding Stallman’s suitability. This would, I hope, have led to his forcible resignation in more or less the same way (even better would have been if he had voluntarily resigned after realizing he’s not the best person to lead the movement, but I rate the chance of that very very low).

                                                                                                                                            Some people would still have been upset, but at least it wouldn’t have triggered the “fairness” feeling and people wouldn’t still be so hung up on it. The end result would have been the same, but the road you use to get there really matters for these kind of things.

                                                                                                                                            Anyway, my point is, this isn’t really about Stallman leading the movement as such, it’s about people feeling he was treated unfairly by some internet mob, and to be honest they’re not completely wrong either. Even when someone does something wrong they deserve the proverbial “fair trail”, and Stallman was denied this. It’s about the redemption of him as a person, rather than as a leader. Some of the replies to my comment on HN are a good example of this, as are some of the comments here.

                                                                                                                                            But it is what it is, has been a year and a half, and high time to move on. Life is unfair, and Stallman is a big boy who can look out for himself. Besides, in the grand scheme of things this is a rather minor unfairness.

                                                                                                                                            1. 16

                                                                                                                                              Even when someone does something wrong they deserve the proverbial “fair trail”, and Stallman was denied this.

                                                                                                                                              I don’t agree with this statement. He resigned from MIT. Universities have procedures for investigating conduct of their employees, especially research staff. He could have gone that route. It is likely that his chances were slim.

                                                                                                                                              At no point, he was denied anything. It’s also not like he was asked to take a position on the things he took positions for.

                                                                                                                                              The other angle is that the general public should conduct fair trials, which is… just not possible.

                                                                                                                                              1. 5

                                                                                                                                                To be honest I’m don’t fully know with what happened at MIT and his position there; it’s not really the thing Stallman is known for or a position that was really all that important, comparatively speaking. I’m not bothered in the slightest that he had to leave that position, or any other. If anything I wish he had resigned from GNU as well and went in to actual proper retirement. It’s just some parts of the road that led up to that I find somewhat distasteful, and also harmful.

                                                                                                                                                The other angle is that the general public should conduct fair trials, which is… just not possible.

                                                                                                                                                I mean “trail” in a broad/poetic sense; not as an actual, well, trail. a fully fair public “trail” is perhaps impossible, but it sure could have been more fair. I think it was completely fair to criticise Stallman, but if you’re going to do that then do it on stuff he actually said and not based on stuff he, well, didn’t.

                                                                                                                                                Also: someone flagged my previous comment as spam; lol?

                                                                                                                                                1. 6

                                                                                                                                                  Also: someone flagged my previous comment as spam; lol?

                                                                                                                                                  My $.02 - people REALLY abuse the flagging system, often for clearly spiteful reasons.

                                                                                                                                                  I don’t get it. These tools are a Big Stick.

                                                                                                                                                  1. 5

                                                                                                                                                    It’s not so bad – it’s just a single flag. As far as these kind of controversial topics go that seems pretty good. I just thought it was funny they chose spam of all reasons. Troll or even unkind I could understand I suppose, but spam?!


                                                                                                                                                    This message was sponsored by Coca Cola.

                                                                                                                                                    1. 3

                                                                                                                                                      It’s just a fact of life in these hellthreads.

                                                                                                                                                  2. 3

                                                                                                                                                    It was my impression that he did not have any sort of formal position at MIT. He had access to an office, but this was a courtesy only. Am I incorrect?

                                                                                                                                                    1. 13

                                                                                                                                                      He was a “visiting scientist”, which is a “formal position” in that the MIT has such a concept and it has reporting requirements. One could even say that him holding that position over more than 1 year is a bit of rule bending. A “courtesy” by an institution such as the MIT also has monetary value (in that Stallman did not need to pay for office space and it comes with credibility).

                                                                                                                                                      It’s a bit unclear whether Stallman still has this office, his website declares that he had it until “around 1998”, in which time he was also living there.

                                                                                                                                                      https://stallman.org/rms-lifestyle.html https://research.mit.edu/research-policies-and-procedures/visiting-and-affiliate-appointments

                                                                                                                                                      All the more a reason why I don’t get the call for a “fair process” - courtesies and hosting guests is explicitly “at will” and I don’t see where any expectation that it should be otherwise comes from?

                                                                                                                                                      1. 2

                                                                                                                                                        Thanks for clarifying.

                                                                                                                                                        And I agree that MIT not continuing to extend the courtesy of the “visiting scientist” position and the office is entirely uncontroversial.

                                                                                                                                                        1. 2

                                                                                                                                                          Happy to!

                                                                                                                                              2. 12

                                                                                                                                                I have to disagree, every time Stallman isn’t around it looks like Free Software slowly becomes secondary to some kind of other social justice movement and Open Source (or some kind of malformed aberration masquerading as open-source) claws away at more and more ground.

                                                                                                                                                1. 17

                                                                                                                                                  The problem is if rms is all that’s standing between OS and FS, then him and the movement aren’t doing a good job of it. Preaching to the converted can only get you so far.

                                                                                                                                                  1. 3

                                                                                                                                                    That’s because, arguably, the pragmatic approach gets more done.

                                                                                                                                                    You can argue that the FSF’s rigorous adherence to philosophical purity is incredibly important and that free software would never be where it is today without it, and you’d be right, but beyond a comparatively small but incredibly important set of software, a more pragmatic approach will get you broader adoption and support.

                                                                                                                                                    Kinda hard to ignore that.

                                                                                                                                                    1. 2

                                                                                                                                                      If we take the pragmatism path, we end up with Open Source, which is similar, but not quite the same.

                                                                                                                                                2. 10

                                                                                                                                                  Bingo. Everyone’s looking at the sideshow, but no one pays attention to the fact rms is not really good at leading a movement, yet somehow has become the single factor for leadership in free software. Will it all crumble like Tito’s Yugoslavia when he goes away?

                                                                                                                                                  A movement isn’t a movement with a single leader, it’s a cult of personality.

                                                                                                                                                  1. 8

                                                                                                                                                    Bingo. Everyone’s looking at the sideshow, but no one pays attention to the fact rms is not really good at leading a movement, yet somehow has become the single factor for leadership in free software.

                                                                                                                                                    This is an (unintentional) strawman. While I do know some people who were very big fans of RMS, at the same time he’s always been presented as a socially-maladjusted radical. There’s no real ‘leadership’ to the free software movement. RMS never made executive decisions which software would or wouldn’t get built. He had a lot of say about the GPL and emacs (his creations), but he was never able to prevent the adoption of other licenses. Or editors, for that matter.

                                                                                                                                                    There have been multiple attempts to sideline him. The Open Source movement being one of them (although ESR turned out to be a much, much, much worse choice of figurehead than RMS ever was or will be).

                                                                                                                                                    The notion that he held a position of significant power (outside running the marginal FSF) is a bit strange. He held a position of influence.

                                                                                                                                                    1. 6

                                                                                                                                                      That comparison is… odd, if you just look at it for a second.

                                                                                                                                                      1. 3

                                                                                                                                                        I am probably biased, as I grew up in said Yugoslavia, but I’m not sure I understand the problem.

                                                                                                                                                        1. 3

                                                                                                                                                          I wouldn’t go as far as calling it problematic, but It’s odd if you compare scenarios that may happen if RMS “leaves” (which he kinda already did) to what happened after Tito’s death. An even (rough) match highly improbably (the GNU project actually has longrunning and collaborative teams, that will probably carry on). It’s highly likely that it will play out in ways where the above statement dilutes into “when leaders go, fundamental changes happen”. Which then makes it odd why Tito, of all people.

                                                                                                                                                          1. 1

                                                                                                                                                            Thanks, makes sense. And I’m sorry for unintentionally replacing “odd” with “problem”.

                                                                                                                                                        2. 2

                                                                                                                                                          I admit just waking up, so the comparison isn’t probably the best. I still stand by the remarks on what happens to a movement with a single point of failure.

                                                                                                                                                      2. 6

                                                                                                                                                        Is there a possibility simple mortality is the reason for his return? He’s a sixty-something programmer, those aren’t in high demand, plus no high-profile company will employ him now.

                                                                                                                                                        If he’s made a fortune as lead developer of Emacs and President of the FSF, he’s been able to hide it very well. The ‘position’ might just be a way for him to avoid homelessness.

                                                                                                                                                        1. 31

                                                                                                                                                          The ‘position’ might just be a way for him to avoid homelessness.

                                                                                                                                                          I’m just going to lay my own cards on the table here: RMS has nobody to blame but himself if he’s in such dire straits. Not some nebulous bogeyman of “cancel culture”. Not journalists. Not newcomers to software communities. Just simply himself.

                                                                                                                                                          Even according to people who like him (I’m not one of them – my only in-person interaction with him was not pleasant), he has more or less spent his entire adult life being told that his personal behavior (which is not the same as his philosophical stances on software or freedom) is… let’s call it “extremely antisocial” to be charitable, but others with more direct and extensive experience of him have used far stronger terms. And effectively he just ignored all that because he didn’t seem to take seriously the idea that antisocial behavior might have social consequences. And there’s no argument to be made here about “he just doesn’t understand that stuff”, because we know multiple people made attempts to explain it to him and connect the dots for him. It wasn’t that he doesn’t know or doesn’t understand. It’s that he made the conscious choice to ignore the warnings and explanations given to him, because he thought it wouldn’t ever apply to him.

                                                                                                                                                          And in one sense he was right, because for many years (decades) he was sheltered by people who had power and influence and the ability to offer him protection and patronage. However, those people now have mostly retired, passed away, and/or lost their influence, and so the piled-up consequences of decades of that behavior have caught up with him. But that’s not anyone else’s fault: he simply never seemed to believe that would happen and so never planned for that day or did anything that might change or avert it. Which is an argument for getting him access to good social services, but not an argument for giving him special sinecure positions and status and power again. He was given second, third, fourth, fifth… hundredth chances to hear the stories told by those who know him well, made use of none of them, and we are no longer obligated to keep giving him more.

                                                                                                                                                          1. 16

                                                                                                                                                            There’s a line in a Bojack Horseman episode which goes something like “once you become famous you stop growing up because you no longer need to, you’ll forever be the age at which you become famous. I became famous when I was 24 so I’ll always be 24”.

                                                                                                                                                            While Stallman isn’t “movie star famous”, he’s clear famous in his own way and about as famous as you can get as a programmer without being an abusive multi-billionare twat like The Zuck. Probably all his detriment in much the same way as it was to Bojack.

                                                                                                                                                            I wrote about my own struggles last year (which is a bit rambling 😅). I “grew up”, so to speak, because I had to, which wasn’t always easy and has included things like getting fired (more than once, too…) and broken long-term relationships. But now, at the age of 35 I feel like I’m a much better person than I was 10 years ago in almost every way, and I hope that in 10 years I’ll be a better person still. Not that I’m necessarily a fan of “harsh lessons”, but sometimes they need to be part of the overall package.

                                                                                                                                                            I’m not sure what would have happened to me if I had been in a similar position as Stallman; I’d rather not think about it to be honest because I find it slightly scary. I think the entire thing is a tragedy really.

                                                                                                                                                            That being said, “let the punishment fit the crime” and Stallman living on the streets is not something I desire upon him (or anyone else for that matter).

                                                                                                                                                            1. 16

                                                                                                                                                              I think a better analogy is what some of the really big tech companies do, where they recruit people right out of university and provide a bunch of things: they help you find an apartment near the office, they send a bus that will take you to work, they have a cafeteria where you can get food when you’re hungry… and so you get people who literally went from parents providing those things, to university providing those things, to employer providing those things. And if they ever quit or get fired, they face a huge struggle to do even very basic stuff, because they never had to before.

                                                                                                                                                              If there’s anything other people did that was a fault, it was how much they sheltered Stallman and prevented him from ever needing to become a functioning adult. He was apparently always dependent on there being someone tolerant enough of him and with enough resources to provide for his basic needs, and one day there was no such person left.

                                                                                                                                                              And again, I don’t think he needs to be thrown out on the streets – I don’t think anyone should be. But there’s a wide gulf between “he should have basic needs met” and “he should get to have positions of high status and influence”. We can do one without needing to do the other, and though I suspect our reasons are different, I think you and I agree that the latter is something we do not need to do and should not do in his case.

                                                                                                                                                              1. 8

                                                                                                                                                                Totally agree. As I said above, I would be very much in favor of any effort to ensure RMS doesn’t become homeless, whether it’s his fault or not.

                                                                                                                                                                I have personally made my career on Linux for easily the past 20 years and I know many others have as well, and Linux would not be the success it is without all the hard work of the GNU developers on things like gcc and coreutils. IMO we do owe him for being a big part of that.

                                                                                                                                                                However I see that as a very different thing from “RMS should be in a leadership position at the FSF”.

                                                                                                                                                                1. 6

                                                                                                                                                                  However I see that as a very different thing from “RMS should be in a leadership position at the FSF”.

                                                                                                                                                                  This is my feeling too in a nutshell. Thank you feoh!

                                                                                                                                                              2. 4

                                                                                                                                                                I agree.

                                                                                                                                                                I would personally support the idea of giving him a stipend to ensure he can keep a roof over his head, and I’d even personally chip in to make that happen, because I do think the free software movement literally wouldn’t exist today without him.

                                                                                                                                                                However, if that’s the case, let’s be straight about it and call it what it is, rather than putting him in a leadership position that potentially blights the organization he hopes to lead.

                                                                                                                                                                1. 5

                                                                                                                                                                  However, if that’s the case, let’s be straight about it and call it what it is, rather than putting him in a leadership position that potentially blights the organization he hopes to lead.

                                                                                                                                                                  Agreed 100% At the same time, you can’t expect a person to easily give up an idea that has literally defined their life. I don’t think he’ll ever gracefully retreat into the shadows, even though he should.

                                                                                                                                                                  I would personally support the idea of giving him a stipend to ensure he can keep a roof over his head, and I’d even personally chip in to make that happen, because I do think the free software movement literally wouldn’t exist today without him.

                                                                                                                                                                  Agreed again. And to people who cast this as ‘hero worship’: It’s not hero worship to acknowledge that a flawed person has accomplished something good.

                                                                                                                                                          1. 17

                                                                                                                                                            Back when they ousted RMS I felt lost. Here was one of the most morally consistent people I knew of, with all that that implies, having to step down as the head of a movement he embodies. While I found the mob justice extremely dishonest and opportunistic, it was uncomfortable to realize that so many around me were OK – or even in favour of it.

                                                                                                                                                            I actually feared for the FSF and their integrity, as such a forced resignation could never ensure a proper transition. They could have easily devolved into something like the Mozilla, which would be a terrible loss. Even if he is not the president of the FSF, I feel better if he continues to play a part in the organisation.

                                                                                                                                                            That being said, and as others have pointed out, he won’t be here forever. It doesn’t have to be death, just age that makes it difficult for him to do his job. While he is back, I think an effort should be made to future-proof the FSF and make sure it stays the FSF. I was hesitant to join the FSF(e) after what had happened, but I’m considering it again now.

                                                                                                                                                            1. 30

                                                                                                                                                              While I found the mob justice extremely dishonest and opportunistic, it was uncomfortable to realize that so many around me were OK – or even in favour of it.

                                                                                                                                                              As someone who follows many communities in the FOSS space, I have a problem with the characterisation of this as mob justice (or maybe we’re disagreeing on a fuzzy term). RMS has been criticised for his opinion pieces on just about everything for a long time and in RMS case, particularly on things he directly wrote on his blog. We’re not even talking about heresay! Those were things like support for necrophilia (on previous consent by the dead), supporting the abortion of people with trisomy 21 (and in passing saying that people should get a pet instead, a statement he later apologised for, to be fair) and other stuff.

                                                                                                                                                              But for a long time, that was rather niche (which also speaks to how many people actually read is blog or just put those statements off). So, to get to my point: if you were not following these things along, it’s easy to say that the people dropping by and making statements are a random and quick mob. But that is not the case: it’s more like the water level has been rising for a long time and suddenly, this criticism breaks into main stream. But of course, year long critics won’t be silent there - for what reason should they? So suddenly, you see a hundred angry voices. But we tend to forget that the day before, we had 99 critics who were ignored for years.

                                                                                                                                                              1. 10

                                                                                                                                                                I don’t think we disagree on what happened, just on our sentiments. Yes , “mob” is a fuzzy term, but I’m specifically referring to the tactics used by Twitter to quickly popularize one side of a story, and force organisations to respond as fast as possible. From my perspective, it felt like a Coup d’état, without any room for debate or compromise.

                                                                                                                                                                Of course a lot of these people were not neutral, but managed to channel their distaste for RMS at the strategically right time, in the right way. Hence “opportunistic”

                                                                                                                                                                Personally, I don’t think that RMS and his position were the best combination. He is a very particular person, that a lot of people are not used to. The paedophilia controversy demonstrates this: While most people accept it to be immoral in principle, he wanted to know why. After all, accusations of paedophilia were used in the same way as accusations of terrorism to infringe on civil rights. I would add that as a culture we have a weird fixation on just-over-18-year-olds that is suspiciously contradictory.

                                                                                                                                                                Any meaningful criticism must start from the actual situation. Simply “banning” him is a one-sided approach that has necessarily lead to disagreement, as one side says it was long overdue, while the others view the action as illegitimate. The fact that those opposed to him did not care about this fact is something I find very disturbing. Hence “disturbing”.

                                                                                                                                                                1. 18

                                                                                                                                                                  I think you missed an important part of the comment you replied to. It wasn’t “quick” or “as fast as possible” or a sudden “coup d’état” – the pressure had been there for years, from many many people. It had been building and building and building. If someone has been unaware of that or not taking it seriously, it can seem sudden, but the only thing that was sudden was the collapse of the network that had supported and protected him from criticism and consequences during all those years (largely due to the Epstein scandal finally breaking into wide public knowledge, which was another case of something building for years and only seeming “sudden” to people who didn’t previously know about it), not the criticism itself.

                                                                                                                                                                  1. 4

                                                                                                                                                                    Considering the section “A short overview of references in chronological order” from this article, the first event in this specific issue happened on September 12., when “Remove Richard Stallman” was published. On September 16. RMS had to resign. That is quick if you ask me.

                                                                                                                                                                    Of course: RMS wasn’t born on September 12., 2019, things happened before, but a coup d’état is not a spontaneous uprising either, but a well thought through, swift plan to change some state of affairs. Hence why it felt like one (to me).

                                                                                                                                                                    1. 11

                                                                                                                                                                      A dam that bursts also tends to fail “suddenly”. Nothing about this surprised me - apart from the fact that RMS didn’t weather this particular storm.

                                                                                                                                                                      In fact, I was vaguely aware of how RMS was viewed by many, many people for years before this. But it took reading the examples in your linked article to really bring it home how weird many of his stated views were.

                                                                                                                                                                      Although to be fair, it’s to his credit that he has not gone back and removed them retroactively.

                                                                                                                                                                      1. 5

                                                                                                                                                                        A dam that bursts also tends to fail “suddenly”.

                                                                                                                                                                        Yes, but a social order inspired on the physics of dams doesn’t seem attractive. Nobody can take all the blame, RMS and the FSF had to see something like this was coming. But if nobody is interested in resolving a conflict, the result will almost always be unsatisfactory.

                                                                                                                                                                        1. 10

                                                                                                                                                                          The testimonies after RMS left were full of examples of people trying to talk to him, trying to reason with him, trying to make him understand that his actions were on the scale from making people very uncomfortable to actively harming people. He didn’t listen - or at least, he did not modify his behavior.

                                                                                                                                                                          That’s what I meant by a dam bursting. It was only surprising to those that saw the edifice as strong and unyielding, but the engineers had been warning about cracks and subsidence for years.

                                                                                                                                                                          1. 2

                                                                                                                                                                            I’d be curious to read these, do you have any links or archives?

                                                                                                                                                                            As I’ve said, my impression has always been that RMS is open to reasoned arguments, but I might be wrong.

                                                                                                                                                                            1. 4

                                                                                                                                                                              Here is a link that’s included in the discussion last year.

                                                                                                                                                                              https://medium.com/@thomas.bushnell/a-reflection-on-the-departure-of-rms-18e6a835fd84

                                                                                                                                                                              1. 2
                                                                                                                                                                              2. 2

                                                                                                                                                                                And finally, this post which I remember reading but not bookmarking, but has shown up again now

                                                                                                                                                                                http://ebb.org/bkuhn/blog/2019/10/15/fsf-rms.html

                                                                                                                                                                                Firstly, all these events — from RMS’ public comments on the MIT mailing list, to RMS’ resignation from the FSF to RMS’ discussions about the next steps for the GNU project — seem to many to have happened ridiculously quickly. But it wasn’t actually fast at all. In fact, these events were culmination of issues that were slowly growing in concern to many people, including me.

                                                                                                                                                                    2. 19

                                                                                                                                                                      Of course a lot of these people were not neutral, but managed to channel their distaste for RMS at the strategically right time, in the right way. Hence “opportunistic”

                                                                                                                                                                      What do you expect of people who have been heavy critics for a long time? Wait until the news cycle is somewhere else again? Sure, this can be seen “opportunistic”, but to be opportunistic, you need to have something ready for the opportunity and that group was on very solid footing. Politics is all about seizing opportunities. And RMS could have addressed all those things over years, or at least not have given people more ammunition.

                                                                                                                                                                      I think it’s illegitimate to ask for enemies with a serious and documented concern (again, the primary source is stallmans website itself), to not follow through on opportunity.

                                                                                                                                                                      I think it’s easy to blame it all on Twitter: 20 years ago, RMS was the only loud voice in the room. What he missed is that he is not the only loud voice in the room anymore and a lot of those voices are not on his side anymore.

                                                                                                                                                                      RMS is not accused of pedophilia. He is accused of questioning the harm caused by it: https://www.stallman.org/archives/2006-may-aug.html#05%20June%202006%20%28Dutch%20paedophiles%20form%20political%20party%29 (EDIT: I don’t pull the quote in here, follow if you want)

                                                                                                                                                                      He does not give reason how consent with a small child is even possible. He’s basically concern-trolling.

                                                                                                                                                                      After all, accusations of paedophilia were used in the same way as accusations of terrorism to infringe on civil rights.

                                                                                                                                                                      Ignoring the stuff around this sentence (tons to unwrap there), I disagree with this fully. People were taking offense with statements such as the above. This has nothing to do with terrorism. This is a false equivalence.

                                                                                                                                                                      No one has “banned” him. But people have been seriously questioning over the years whether he is the right person to take this seat, especially when there’s better ones available. It’s not like that’s a zero sum game: a seat as a director of the FSF is also a seat taken for someone else.

                                                                                                                                                                      1. 5

                                                                                                                                                                        What do you expect of people who have been heavy critics for a long time?

                                                                                                                                                                        I don’t imply I it is surprising. It would be stupid for them to not go through with it, given their goals.

                                                                                                                                                                        And RMS could have addressed all those things over years, or at least not have given people more ammunition.

                                                                                                                                                                        I’m sceptical of this, as many people have already made up their minds about him, either because they do not like his ideas of free software or his other view. After all, he does change his mind, but that was not important. No matter what he does, you can always come up with an accusation that it was too little, too late.

                                                                                                                                                                        He does not give reason how consent with a small child is even possible. He’s basically concern-trolling.

                                                                                                                                                                        I don’t care much for neologisms like “concern-trolling”, and we will probably disagree here, but I think that a virtue of his is honesty. He isn’t hiding any position, he isn’t preparing a different argument. He just says that he doesn’t understand something, and doesn’t insist on it as a dogmatic point. All he wants to here is a reasoned argument, which should always be possible, but instead all people throw back at him are insults and accusations.

                                                                                                                                                                        People were taking offense with statements such as the above. This has nothing to do with terrorism. This is a false equivalence.

                                                                                                                                                                        I am elaborating an argument, I would be very grateful if you stopped reading me in bad faith. If something I wrote is confusing or hard to understand, ask, don’t guess.

                                                                                                                                                                        1. 7

                                                                                                                                                                          I’m sceptical of this, as many people have already made up their minds about him, either because they do not like his ideas of free software or his other view.

                                                                                                                                                                          Occam’s Razor. What is the simpler explanation: personal vendetta against the guy, or honest disapproval of his stated positions?

                                                                                                                                                                          1. 1

                                                                                                                                                                            Of yes, most will probably not have cared or just dislike him. Without any further evidence, claims like a Vendetta shouldn’t be made. But I know of people like that who do exist. Sahra Mei, a Twitter complains about RMS all the time, and she absolutely loathes RMS and the FSF:

                                                                                                                                                                            I’ve been a diehard free & open source software user, contributor, and backer since college in the 90s. But at this point, I would rather run proprietary software that I can NEVER see or change if the alternative is to run software licensed by the FSF.

                                                                                                                                                                            I am not sure, but I believe that Coraline Ada Ehmke (the author of the Hippocratic License) also has a history with RMS, but I couldn’t find anything on that right now.

                                                                                                                                                                            These kinds of people have made up their mind, and have classified RMS as unsalvageable.

                                                                                                                                                                            1. 5

                                                                                                                                                                              These kinds of people have made up their mind, and have classified RMS as unsalvageable.

                                                                                                                                                                              Everyone who looks into this finds stories of people close to Stallman telling him that his personal behavior is a large problem. Over and over. For years. And always the story ends with Stallman not changing at all, because he believes it won’t ever matter – nobody ever held him accountable or made him face consequences before, and so he doesn’t expect anyone ever will in the future.

                                                                                                                                                                              At what point is it OK to just say “yeah, people have tried for years to ‘salvage’ here, given second chances, third chances, hundredth chances, and nothing changed, so let’s move on”? At what point, in your view, is it acceptable for everyone else to decide to be done with trying to explain and get him to change when he has made it abundantly clear that he has no intention of ever being receptive to that? Do we have to give him a thousand chances? Ten thousand? A million? Does everybody get that many chances, or just him? Do we ever stop to weigh against the cost of people who might be driven away from the movement by this one dude? And why is it literally every other living human’s job (seemingly) to be endlessly willing to re-re-re-re-re-re-re-re-re-re-re-re-re-re-re-re-re-explain to him and give him the two hundred quintillionth chance, rather than his job to either figure out how to behave like a decent person, or else face people not wanting anything to do with him?

                                                                                                                                                                              The Free Software movement is actively held back by Richard Stallman and by the the need of some people to focus the movement on him personally rather than on a philosophy. Stallman at this point is effectively only able to preach to the already-converted, and even struggles with that – plenty of people will say things like what you quoted above, about agreeing with the ideals but being turned off by the person. And he has made it abundantly clear that he will never voluntarily change or step back. So the only way forward for Free Software is to leave Stallman behind.

                                                                                                                                                                              1. 6

                                                                                                                                                                                The Free Software movement is actively held back by Richard Stallman…So the only way forward for Free Software is to leave Stallman behind.

                                                                                                                                                                                Not one of my non programmer friends knows who RMS is. The Civil Rights movements had thousands of leaders. There are many organizations fighting the #imaginaryProperty system. We don’t need RMS or FSF to lead anything. We need them to be the best versions of RMS and FSF they can be.

                                                                                                                                                                                I can tell you there is a ton of money that has been actively trying to turn people against RMS for decades. If I was him it would be very hard to tell which people to trust, and perhaps I wouldn’t have changed potentially bad habits either. Sometimes being an early leader is very lonely.

                                                                                                                                                                                One of my great regrets in life was not doing more to support aarsonsw when he was being attacked. I should have done more but I didn’t. As the saying goes, freedom isn’t free. It takes people of courage like RMS and aarsonsw and AE who stand up to a great evil that 90% of people don’t think about it and 9% of people actively are paid to promote. That’s gotta be a lonely place to me, especially in the early days.

                                                                                                                                                                          2. 3

                                                                                                                                                                            I just want to say I found your comments really well put! Some good conversation in this thread.

                                                                                                                                                                            I’ve read RMS’ writings and software for years. As far as I remember it is 99% about free software, and 1% about random stuff. To judge him on a fraction of the random stuff is not fair, IMO. I want to see any critic of his on these issues do an honest text data analysis to figure out how much of his writing is truly about the things they accuse him of. My guess is it will round to zero (but I could be wrong and would give an honest read if anyone truly cared about this as evidenced by actually doing any hard work).

                                                                                                                                                                            The one point that does concern me is if women who have worked around him have not felt it to be a comfortable work environment. That is something I’ve found to be true at nearly every tech organization, and I would be surprised if FSF was different, and I hope they can do an audit and serious investigation on how to make huge improvements on that front, if that is the case. I read a relevant article recently with some tips: https://www.forbes.com/sites/kendalltucker/2019/04/26/startup-accelerators-contributing-to-or-working-against-tech-diversity/ (and I’m always looking to read more if people have suggestions!)

                                                                                                                                                                            1. 6

                                                                                                                                                                              Stallman writes about politics every single day on his personal website. He probably writes more about non-free-software politics than anything else these days.

                                                                                                                                                                              1. 1

                                                                                                                                                                                Thank you. I was wrong, he certainly does write a lot about non software stuff. I guess I was viewing a biased sample (I was always reading his content about software). Appreciate you pointing that out.

                                                                                                                                                                              2. 2

                                                                                                                                                                                As @hungariantoast says, a lot of his day-to-day writing is regular politics. But I think that you are right that only an extreme minority of his posts are the controversial ones. For the most part, he appears to be a regular social democrat, advocating for healthcare, climate protection, women’s rights, etc.

                                                                                                                                                                                I have never met RMS in person, though we have communicated, and I understand what people mean. The crux of my problem is the matter in which he was treated and the issues that raises for the free software movement and their legitimacy as a whole.

                                                                                                                                                                                Edit: And thank your for your compliment, I was worried my comments were badly written.

                                                                                                                                                                      2. 10

                                                                                                                                                                        Back when they ousted RMS I felt lost. Here was one of the most morally consistent people I knew of

                                                                                                                                                                        RMS is really the only reason I began to care about Free Software. His personality, consistency, and unwavering resiliency in the face of everything that opposes the movement is impressive and, to a teenager interested in software, enthralling; Free Software really set a foundation for some of my later views on ethics, justice and philosophy, and I feel for many other people he did just the same.

                                                                                                                                                                        1. 10

                                                                                                                                                                          And yet when others take a stance of unwavering resiliency on what they see as justice, you seem to think (based on your comments here) it is unfair. Which is logically inconsistent – if it is acceptable for one person to be so unforgivingly harsh in the pursuit of their moral system, it is acceptable for another person to do the same.

                                                                                                                                                                          In ethics, this is usually when we break out Kant and the categorical imperative, and ask someone to consider “how would the world look if everybody – including people with different ideas of what’s right/just/etc. – were to adopt this way of acting”. If you do not like what you see, then it’s an argument against that way of acting.

                                                                                                                                                                          1. 4

                                                                                                                                                                            I don’t think it’s unfair they take a stance on something (that’s their right imbued unto them by nature’s creator), I simply don’t believe they are fighting for anything just.

                                                                                                                                                                            1. 3

                                                                                                                                                                              You’re going to have to be a bit more specific about who “they” are and “what” they are fighting for that you believe is unjust while free software is just.

                                                                                                                                                                              I find it really dissonant, the fact that people get amped up on the social justice movement that is free software, which nominally represents equal opportunity / autonomy / freedom of expression, and then turn around and fight against longer lived social movements that advocate for the exact same set of core values, and that have paved the way for free software.

                                                                                                                                                                              1. 5

                                                                                                                                                                                I’m not sure what you think I believe, nor is lobste.rs the place to have a discussion about politics tangential to the discussion at hand.