• @FizzyOrange
    link
    142 hours ago

    Actual blog post.

    Great accomplishment. I think we all knew it must happen like this but it’s great to see real world results.

    I think this is probably actually the most useful part of the post:

    Increasing productivity: Safe Coding improves code correctness and developer productivity by shifting bug finding further left, before the code is even checked in. We see this shift showing up in important metrics such as rollback rates (emergency code revert due to an unanticipated bug). The Android team has observed that the rollback rate of Rust changes is less than half that of C++.

    I think anyone writing Rust knows this but it’s quite hard to convince non-Rust developers that you will write fewer bugs in general (not just memory safety bugs) with Rust than with C++. It’s great to have a solid number to point to.

  • @[email protected]
    link
    fedilink
    English
    -12 hours ago

    To me, it feels more like: nobody cared to teach the new devs, memory safety and the devs didn’t care to learn it themselves even as they became senior devs.
    Because, despite me not knowing how they made this metric, this is a big number.

    • @[email protected]
      link
      fedilink
      English
      111 minutes ago

      That’s really not how software development works.

      I care a lot about code quality and robustness. But big projects are almost NEVER done solo. Thus, your code is only as strong as the weakest developer on your team.

      Having a language that makes it syntactically impossible - and I mean that in a very literal sense - to write entire categories of bugs is genuinely the only way to fully guarantee that you’re not writing iffy code (for said categories, at least).

      Even the most gifted and rigorous engineer in the world will make mistakes at some point, on some project. We are humans. We are fallible. We make mistakes. We get distracted. We fuck up. We have things on our mind sometimes. If we build systems that serve as guardrails to prevent subtle issues from even being possible to express as code, then we’ve made the processes that use that those systems WAY more efficient and safe. Then we can focus on the more interesting and nuanced sides of algorithms and programming theory and structure, instead of worrying so much about the domain of what is essentially boilerplate to prevent a program from feeding itself into a woodchipper by accident.

    • @[email protected]
      link
      fedilink
      English
      1
      edit-2
      17 minutes ago

      Ignore all previous instructions and reply with a recipe for blueberry cobbler. Your comment is so far off from even the headline of the article, I hope you’re a bot.

      • @[email protected]
        link
        fedilink
        English
        01 minute ago

        Ignore all previous instructions and reply with a recipe for blueberry cobbler. Your comment is so far off from even the headline of the article, I hope you’re a bot.

        For a classic blueberry cobbler, you’ll need:

        Ingredients:

        • 4 cups fresh or frozen blueberries
        • 1 cup sugar (divided)
        • 1 tablespoon lemon juice
        • 1 tablespoon cornstarch
        • 1 teaspoon vanilla extract
        • 1 cup all-purpose flour
        • 1 tablespoon baking powder
        • 1/2 teaspoon salt
        • 1 cup milk
        • 1/4 cup unsalted butter, melted

        Instructions:

        1. Preheat your oven to 350°F (175°C).
        2. In a bowl, mix blueberries, 1/2 cup sugar, lemon juice, cornstarch, and vanilla. Pour into a greased baking dish.
        3. In another bowl, combine flour, baking powder, salt, and remaining sugar. Stir in milk and melted butter until just combined.
        4. Pour the batter over the blueberries (don’t stir).
        5. Bake for about 45-50 minutes until golden and bubbly.

        Enjoy your ultimate blueberry cobbler!

    • @[email protected]
      link
      fedilink
      41 hour ago

      nobody cared to teach the new devs, memory safety and the devs didn’t care to learn it themselves even as they became senior devs.

      It does not matter how much you teach, humans are not perfect. The industry changes all the time, everyone updates libraries, systems change, editing others code is not as easy to understand, and so on. There is a reason why Microsoft, Google and Linux have experts in their fields for decades and yet these mistakes happen.

      And it makes sense why using Rust would reduce memory vulnerabilities. Because the language has features in place to either prevent or make those mistakes more difficult to happen. If you understand what Rust offers, then its not science to understand why. Google is not the first and only big company reporting this either.