Rust Memory Management: Ownership vs. Reference Counting
slicker.me
  • onlinepersona
    3·
    23 hours ago

    Rust ownership and async have been the worst part of my Rust experience. I normally either use a reference or copy and that solves 90% of my problems.

    Rust prides itself on “fearless concurrency” but as I said, async is horrific. I’ve spent way too much time trying to build an pipeline that downloads data from a source and spreads it out to multiple consumers who can also pass data on or terminate gracefully. The experience left me so annoyed that I just moved to a worker based model with Kafka in between and let every worker download the file to do its processing. So much simpler.

    Having to do shit concurrently in rust is amongst my biggest fears because of async. I’d rather use python or even JavaScript which have functional and easy async.

    • BB_C
      1·
      14 hours ago

      “Fearless Concurrency” predates “async” in rust nomenclature, and points to specific compile-time guarantees around things like thread safety and races (Send, Sync, …).

      It was around when we used event loops and the mio crate (and rayon for parallelism), with no async or await in sight (because they didn’t exist yet).

      Some people actually still prefer to do “concurrency” this way, especially if they wish to stay close to the abstraction level from C land. io_uring also came later which introduced a new OS low-level interface and paradigm for doing “concurrency”.

      “Fearless Concurrency” has nothing to do with how easy you can write async code, especially if you’re someone who struggles with the language basics like ownership.

  • nousEnglish
    4·
    2 days ago

    The ownership model is Rust’s core innovation. Every heap allocation has exactly one owner — the variable binding that “holds” it. Ownership can be moved to another binding, at which point the original is invalidated. It can never be silently copied (unless the type implements Copy).

    While each of these is not wrong in isolation, together they are. If we are talking about data stored on the heap that last bit is not true. Types that hold a raw pointer cannot be made Copy. Only simple types can be made Copy, ones that don’t own any non direct data and as such can be stored on the stack and simply memcpyed to get a copy.