I am not hating on Rust. I am honestly looking for reasons why I should learn and use Rust. Currently, I am a Go developer. I haven’t touched any other language for years, except JavaScript for occasional front end work and other languages for OSS contributions.

After working with almost every mainstream language over the years and flitting between them on a whim, I have fallen in love with Go. It feels like ‘home’ to me - it’s comfortable and I enjoy working with it and I have little motivation to use anything else. I rage every time I get stuck working with JavaScript because dependency management is pure hell when dealing with the intersection of packages and browsers - by contrast, dependency management is a breeze with Go modules. I’ll grant that it can suck when using private packages, but I everything I work on is open.

Rust is intriguing. Controlling the lifecycle of variables in detail appeals to me. I don’t mind garbage collectors but Rust’s approach seems far more elegant. The main issue for me is the syntax, specifically generic types, traits, and lifetimes. It looks just about as bad as C++'s template system, minus the latter’s awful compiler errors. After working almost exclusively with Go for years, reading it seems unnecessarily demanding. And IMO the only thing more important than readability is whether it works.

Why should I learn and use rust?

P.S.: I don’t care about political stuff like “Because Google sucks”. I see no evidence that Google is controlling the project. And I’m not interested in “Because Go sucks” opinions - it should be obvious that I disagree.

  • TechNom (nobody)@programming.dev
    link
    fedilink
    English
    arrow-up
    2
    ·
    1 year ago

    I don’t know how useful Options are in Python, with its duck typing. Python had something similar to Option::None all along - None. It’s possible to use None in Python is very idiomatic and surprising ways. Rust’s Some and None are tagged unions. And Rust forces you to address them - unlike Python.

    • aes@programming.dev
      link
      fedilink
      English
      arrow-up
      1
      ·
      1 year ago

      Well, with the newer optional typing, it became def foo(name: Optional[str]) -> Optional[str]: ... and now def foo(name: str | None) -> str | None: ... (No need to import Optional) It’s quite nice.

      As for Rust, recall that Result is also a very similar union type. I think a lot of the aversions people have had to static typing have mostly just been about poor expressiveness in clunky type systems.

      • TechNom (nobody)@programming.dev
        link
        fedilink
        English
        arrow-up
        1
        ·
        1 year ago

        I have been programming in Python for nearly two decades now. This is the first I’m hearing about the Optional improvements to Python’s type hints/annotations. Thanks a lot for this. I’m going to take a re-look into type hints.

        As for Rust, recall that Result is also a very similar union type.

        I’m aware that Rust enums, including Result, are tagged unions. However, my understanding is that it’s not like that in Python. Python’s duck typing is enabled by typing the values, rather than the variables. A variable can point to a value of any type. Am I getting this wrong? Or is Optional different somehow?