• MajorHavoc@programming.dev
    link
    fedilink
    arrow-up
    0
    ·
    9 months ago

    It’s not really any faster to do things unsafe

    Yeah. Which is how I roll with Python now, as a Python Zen master. But Python was a little charmer when I was learning it to replace my Perl scripts.

    In contrast, Rust would not shut up the last time I was trying to do an unsafe local bubble sort, just to get to know it. What I got to know was that I was working with a language that was going to go out of it’s way to get in my, each time way I wanted to do something it didn’t like.

    Rust was easily the worst first date with a programming language I have had in a long time, and I can code in both varieties of ‘Pikachu’.

    Again, it’s just my first impression, not the last word on the language. But I have enough tools in my belt that I didn’t need to add Rust.

    I’ll try that ‘unsafe’ flag next time, and we will see if it can sort my local music files by artist name without having a security fit.

    • Fal@yiffit.net
      link
      fedilink
      English
      arrow-up
      0
      ·
      edit-2
      9 months ago

      You’re missing the point. Tools are different. Trying to learn and use rust by writing unsafe bubble sort is pointless. Use it to actually accomplish something and you’ll find out just how amazing it is.

      Using the ecosystem that exists to be productive and not have to think at all about whether what you’re doing is correct is the point. It catches the subtle errors for you and lets you use the powerful libraries like clap for command line parsing, tokio, etc.

      • MajorHavoc@programming.dev
        link
        fedilink
        arrow-up
        0
        ·
        edit-2
        9 months ago

        I wasn’t being that picky, and I was using the ecosystem. Rust just has lousy compiler warnings.

        I know dozens of languages, so I don’t mind risking looking dumb when I say “this tool isn’t very good yet”.

        Rust’s compiler, considering what it asks for, isn’t good enough at guiding the developer toward those asks. It actively wastes the one crucial low-supply computing resource: developer time.

        I could have figured it out, if I had to. But I didn’t have to. I moved on to the next interesting language to try out. It was goLang, and it had isn’t own bullshit, but it wasn’t as bad as Rust.

        I’ve written in Haskell and Brainfuck. I don’t mind esoteric languages.

        But Rust presents itself as a solid general purpose pragmatic development tool, which is great to strive for, but it wasn’t there yet, last time I gave it a chance.

        I want Rust to succeed in replacing Python, because the world would be better off with better security defaults. But Rust had not, last I checked, attracted the necessary usability specialist contributors, to have any chance at that goal.

        • Fal@yiffit.net
          link
          fedilink
          English
          arrow-up
          0
          ·
          9 months ago

          Rust just has lousy compiler warnings.

          You’re the only person I’ve ever heard this from. Rust’s compiler warnings are amazing. Like 2nd to none

      • MajorHavoc@programming.dev
        link
        fedilink
        arrow-up
        0
        ·
        9 months ago

        Thanks. I found and tried that, but what I really needed was a useful compiler error, which Rust did not provide.

        Rust desperately needed a usability makeover, last time I tried it.

        It amuses me that my fellow security gurus push Rust hard, because we sit in the same policy-pushers conferences as the usability specialists, but we don’t always learn enough from them.

        • force@lemmy.world
          link
          fedilink
          arrow-up
          0
          ·
          edit-2
          9 months ago

          Sorry what? Rust has literally been known for having some of the most useful compiler warnings imaginable. It’s like, a huge selling point. Misleading warnings are far and few, and usually it’ll literally point you at the exact tokens that caused an error and gives you a solution to fix it.

          Are you sure that your inability to write Rust isn’t caused by a lack of understanding of the language’s pointer/ownership/lifetime rules, or the type system? I would be inclined to believe that someone who mainly just uses Python (or any other GC’d language really, but especially extremely high-level/“low-code” dynamically-typed languages like Python/Lua/JavaScript) wouldn’t exactly be too good at those concepts, but they’re pretty important in the context of languages like Rust.