• rbn@sopuli.xyz
      link
      fedilink
      arrow-up
      1
      ·
      18 days ago

      A platform that is doing a great job so far but which (unfortunately) isn’t as relevant yet to call it a pillar of modern infrastructure. ;)

  • LordKitsuna@lemmy.world
    link
    fedilink
    arrow-up
    1
    ·
    18 days ago

    I get the joke, but rust is actually pretty heavily used in the backend of services theae days. Cloudflare, Amazon, Dropbox, just to randomly name a few off the top my head. Have pretty heavily invested it into their back ends for more reliable service.

    • CatLikeLemming@lemmy.blahaj.zone
      link
      fedilink
      English
      arrow-up
      0
      ·
      18 days ago

      Over the last one or two years I feel like Rust haters have gotten even louder than the Rust evangelists. For every person who declares “Rewrite it in Rust!” I see two or three people saying how they hate Rust or how pointless it is and so on.

  • vga@sopuli.xyz
    link
    fedilink
    arrow-up
    1
    ·
    edit-2
    18 days ago

    Rust is fearlessly upholding the whole thing even without touching it. Incredible!

  • Simulation6@sopuli.xyz
    link
    fedilink
    arrow-up
    0
    ·
    18 days ago

    Rust is actually awesome in many ways. No always the right solution, but nice to have in your toolbox.

    • Croquette@sh.itjust.works
      link
      fedilink
      arrow-up
      0
      ·
      18 days ago

      Where would you say Rust isn’t the right solution?

      We always hear how great Rust is, but I’d be curious to know where it isn’t.

      • rumba@lemmy.zip
        link
        fedilink
        English
        arrow-up
        1
        ·
        18 days ago

        Rust provides safety and protection.

        Rust isn’t as rapid as other options, has less library support, and porting existing code is relatively difficult.

        IMO because of the workarounds you need to do to handle the memory safety, you end up with a lot more hard to solve bugs than you do with conventional languages. It should be noted however that the bugs don’t end up being security vulnerabilities like they do in conventional systems.

        If you have something that needs to be structurally sound and/or you have enough talented people willing to work on it, it’s a great option. If it needs to be fast and cheap and you don’t have a gaggle of rust developers on hand and it’s already written in another language, it might not be the best solution.

      • NeatNit@discuss.tchncs.de
        link
        fedilink
        arrow-up
        0
        ·
        18 days ago

        Never used Rust but I’d like to point out the YouTube channel Low Level which covers security vulnerabilities (CVEs). He ends each video with “would Rust have fixed this?” and it’s pretty interesting.

        A very recent one is this: https://youtu.be/BTjj1ILCwRs?t=10m (timestamped to the relevant section)

        According to him, when writing embedded software in Rust (and UEFI is embedded), you have to use Rust in unsafe mode which basically disables all the memory safety features. So in that kind of environment Rust isn’t really better than C, at least when it comes to memory safety.

        That’s not to say Rust isn’t still a good option. It probably is.

        Again, I never used Rust so I’m just parroting stuff I’ve heard, take all of this with a grain of salt.

        • calcopiritus@lemmy.world
          link
          fedilink
          arrow-up
          1
          ·
          18 days ago

          Rust doesn’t have “safe” and “unsafe” modes in the sense your comment alludes to.

          You can just do the little unsafe thing in a function that guarantees its safety, and then the rest of the code is safe.

          For example, using C functions from rust is unsafe, but most of the time a simple wrapper can be made safe.

          Example C function:

          int arraysum(const int *array, int length) {
              int sum = 0;
              while (length > 0) {
                  sum += *array;
                  array++;
                  length--;
             }
          }
          

          In rust, you can call that function safely by just wrapping it with a function that makes sure that length is always the size of array. Such as:

          fn rust_arraysum(array: Vec<i32>) -> i32 {
              unsafe{ arraysum(array.as_ptr(), array.len() as i32)}
          }
          

          Even though unsafe is used, it is perfectly safe to do so. And now we can call rust_arraysum without entering “unsafe mode”

          You could do similar wrappers if you want to write your embedded code. Where only a fraction of the code is potentially unsafe.

          And even in unsafe blocks, you don’t disable all of the rust checks.