1. 31
  1.  

  2. 10

    Posted 6 hours ago, so the first people may have started finished reading :).

    1. 6

      This person’s stream-of-consciousness style drives me crazy 🤯. I’m not going to spend 20 minutes reading a post with no idea what the point is eventually going to be. I reserve that for writers like Thomas Pynchon, whom I will allow to digress for 20 pages about Turkic languages, or colonialism in South Africa, because he’s Thomas Fscking Pynchon. This guy, I’m not so sure.

      He had a decent, if obvious, point about compile-time checks saving time over the program’s lifecycle, but then I gave up after a few screenfuls about SSH attacks and HTTP parsing. I assume that’s going to tie into his grand theme later on, but I’d rather go find something that doesn’t bury the lede in a coal mine.

      Plus, his cartoon asides aren’t as funny as Why The Lucky Stiff’s were.

      1. 6

        Style and comics are a matter of taste, I will give you that. What remains, to me, is that Amos lists three statements:

        1. Programming in Rust requires you to think differently
        2. It is harder to write any code at all in Rust
        3. It is easier to write “correct” code in Rust

        Most of the article is centered on proving the last point, by going through a lengthy example with NodeJS and Go only to come back to Rust in the end to demonstrate said point. I for one appreciate long form, in-depth content like this.

        1. 1

          Programming in Rust requires you to think differently

          I hate this, because it presumes a lot about how the reader thinks in the first place. And if the author of such a statement is going to make sweeping assumptions about how I think, then they’re likely to make sweeping assumptions elsewhere too.

          1. 0

            If they’re aiming at correctness, a language like Haskell is better; Rust is, ultimately, a compromise with correctness and speed on current machines, and it dumps correctness too often to be safe in any real sense. Rust’s focus on “types” which merely specify the size in bits (making them fail to be types, as they do nothing to catch invalid operations) proves that it’s a systems programming language, as opposed to one with any emphasis on correctness beyond the superficial.

            1. 12

              Rust’s focus on “types” which merely specify the size in bits (making them fail to be types, as they do nothing to catch invalid operations)

              Um, where did you hear this? That’s not right at all.

              1. 6

                Did you read the article?

                1. 4

                  It took me a bit to understand where you might be standing (and unflag the comment).

                  Still, I vehemently disagree: Rust type system might be weaker than Haskell’s (yes, no HKT and any way to do monads, no tons of advanced type system extensions), but it’s so much more than just specifying bit sizes. It’s the first time we have ADTs in a semi-mainstream systems programming; traits are direct translation of Haskell typeclasses. Borrow checker is a unique development that only now finds its way into GHC in much more experimental form.

                  Haskell, on the other hand, has quite many non-typesafe footguns like non-exhaustive pattern matching, partial functions, laziness (which is not reflected in the type system at all, poisons it with bottom everywhere, explodes into space leaks, sneaks in lazy I/O, makes reasoning about runtime a nightmare) and still not expressive enough to avoid occasional Template Haskell and verify monad laws mechanically.

              2. 4

                every one of his articles reads like this. I’m digging it for like a page or two and then he goes into some extremely specific corner case that just reads like he found a bug and he has a massive axe to grind about it. I want to like his writing more than I do, he seems to be pointed in the right direction.

              3. 3

                It took me four days to read, but it was a delightful piece.

                It also gave me new insights into just how backwards Go is, even when it comes to something as simple as initialising a struct.

                1. 2

                  The good news for you: there’s more content on his blog, including https://fasterthanli.me/articles/i-want-off-mr-golangs-wild-ride

                2. 3

                  I, for one, enjoy this kind of writing. I always learn a ton of stuff on some deep technical details, and I quite like that.