• Ephera@lemmy.ml
    link
    fedilink
    arrow-up
    11
    ·
    1 month ago

    Yeah, arguably the only answer to this question is Rust.

    Java/C#/etc. are not fully compiled (you do have a compilation step, but then also an interpretation step). And while Java/C#/etc. are memory-safe in a single-threaded context, they’re not in a multi-threaded context.

      • Ephera@lemmy.ml
        link
        fedilink
        arrow-up
        4
        ·
        1 month ago

        I mean, yeah, valid point. JVM languages also have GraalVM for that purpose.

        But I’m playing devil’s advocate here. 🙃

        Arguably these don’t count, because they’re not the normal way of using these languages. Reflection isn’t properly supported in them, for example, so you may not be able to use certain libraries that you’d normally use.

        These also still require a minimal runtime that’s baked into the binary, to handle garbage collection and such.
        Personally, I enjoy fully compiled languages, because they generally don’t lock you into an ecosystem, i.e. you can use them to create a library which can be called from virtually any programming language, via the C ABI.
        You cannot do that with a language that requires a (baked-in) runtime to run.

        But yeah, obviously someone just specifying “compiled” probably won’t have all these expectations…

      • Ephera@lemmy.ml
        link
        fedilink
        arrow-up
        2
        ·
        1 month ago

        I don’t know much about C++, but how would that do memory safety in a multi-threaded context? In Rust, that’s one of the things resolved by ownership/borrowing…

        Or are you saying arguably, as in you could argue the definition of the categories to be less strict, allowing C++ as well as Java/C#/etc. to match it?

        • Saizaku@lemmy.dbzer0.com
          link
          fedilink
          arrow-up
          6
          ·
          1 month ago

          Because you would be using std::shared_ptr<> rather than a raw pointer, which will automatically deallocate the memory when a shared point leaves the scope in the last place that it’s used in. Along with std::atmoic<shared_ptr> implements static functions that can let you acquire locks and behave like having a mutex.

          Now this isn’t enforced at the compiler level, mostly due to backwards compatibility reasons, but if you’re writing modern c++ properly you wouldn’t run into memory safety issues. If you consider that stretching the definition then I guess I am.

          Granted rust does a much better job of enforcing these things as it’s unburdened by decades of history and backwards compatibility.

      • arendjr@programming.dev
        link
        fedilink
        arrow-up
        1
        ·
        1 month ago

        Modern C++ does use references, which can also reference memory that is no longer available. Avoiding raw pointers isn’t enough to be memory safe.

        • nous@programming.dev
          link
          fedilink
          English
          arrow-up
          10
          ·
          1 month ago

          I don’t think data races are generally considered a memory safety issue. And a lot of languages do not do much to prevent them but are still widely considered memory safe.

          • calcopiritus@lemmy.world
            link
            fedilink
            arrow-up
            3
            ·
            1 month ago

            Even though they are not what people mean when they say “memory-safe”, it is technically a kind of memory safety. It is unsafe to modify non-mutexed/non-atomic memory that another thread might be modifying at the same time.

          • Ephera@lemmy.ml
            link
            fedilink
            arrow-up
            4
            arrow-down
            2
            ·
            1 month ago

            Yeah, that is why I prefixed that whole comment with “arguably”.

            I feel like the definition of memory safety is currently evolving, because I do think data races should be considered a memory safety issue.
            You’ve got a portion of memory and access to it can be done wrongly, if the programmer isn’t careful. That’s what memory safety is supposed to prevent.

            Rust prevents that by blocking you from passing a pointer for the same section of memory into different threads, unless you use a mutex or similar.
            And because Rust sets a new safety standard, I feel like we’ll not refer to Java and such as “memory-safe” in twenty years, much like you wouldn’t call a car from the 90s particularly safe, even though it was at the time.

            • Saizaku@lemmy.dbzer0.com
              link
              fedilink
              arrow-up
              5
              ·
              1 month ago

              There’s a reason why data races aren’t considered a memory safety issue, because we have a concept that deals with concurrency issues - thread safety.

              Also for all it’s faults, thread and memory safety in java aren’t issues. In fact java’s concurrent data structures are unmatched in any other programming language. You can use the regular data structures in java and run into issues with concurrency but you can also use unsafe in rust so it’s a bit of a moot point.

              • Ephera@lemmy.ml
                link
                fedilink
                arrow-up
                4
                ·
                1 month ago

                Oof, I guess, you’re not wrong that we’ve defined data races to be the separate issue of thread safety, but I am really not a fan of that separation.

                IMHO you cannot cleanly solve thread safety without also extending that solution to the memory safety side.
                Having only one accessor for a portion of memory should just be the n=1 case of having n accessors. It should not be the other way around, i.e. that multiple accessors are the special case. That just leads you to building two different solutions, and to thread safety being opt-in.

                That’s also the major issue I have with Java’s solution.
                If you know what you’re doing, then it’s no problem. But if you’ve got a junior hacking away, or you’re not paying enough attention, or you just don’t realize that a function call will take your parameter across thread boundaries, then you’re fucked.
                Well, unless you make everything immutable and always clone it, which is what we generally end up doing.

              • arendjr@programming.dev
                link
                fedilink
                arrow-up
                2
                ·
                1 month ago

                You can use the regular data structures in java and run into issues with concurrency but you can also use unsafe in rust so it’s a bit of a moot point.

                In Java it isn’t always clear when something crosses a thread boundary and when it doesn’t. In Rust, it is very explicit when you’re opting into using unsafe, so I think that’s a very clear distinction.

                Java provides classes for thread safe programming, but the language isn’t thread safe. Just like C++ provides containers for improved memory safety, and yet the language isn’t memory safe.

                The distinction lies between what’s available in the standard library, and what the language enforces.

        • paperplane@lemmy.world
          link
          fedilink
          arrow-up
          2
          ·
          1 month ago

          Swift does have data race safety as of Swift 6 with their actor-based concurrency model and are introducing noncopyable types/a more sophisticated ownership model over the next few releases

          • Ephera@lemmy.ml
            link
            fedilink
            arrow-up
            1
            ·
            1 month ago

            Hmm, that sounds quite interesting. But because I’ve had to rebut that for everyone else that responded: Is it opt-in?

            I guess, I would be fine with opt-in for the actor pattern, since you either do actors in your whole codebase or you don’t, but otherwise, opt-in often defeats the point of safety measures…

            • paperplane@lemmy.world
              link
              fedilink
              arrow-up
              2
              ·
              29 days ago

              It’s opt-in in Swift 5 mode and opt-out in Swift 6 mode, the Swift 6 compiler supports both modes though and lets you migrate a codebase on a module-by-module basis.

              Agree that opt-in sort of defeats the point, but in practice it’s a sort of unavoidable compromise (and similar to unsafe Rust there will always be escape hatches)