The comments gives a link to a recent talk about the motivation for using Rust in Git: https://github.com/bk2204/talk-rust-in-git/blob/dev/presenta...

I wouldn't agree with all of those reasons, but it's very definitely not "just for the sake of it." One of the better reasons so many people look to writing some things in Rust is that we now have pretty ample evidence than trying to write a binary file format parser in C is a cornucopia of CVEs that are just simply absent in Rust, and the excuse of "well, but a sufficiently smart programmer doesn't write bugs in C" doesn't cut it anymore.

Somehow we also have memory safety bugs everywhere, too. So real world shows bugs in C code are possible. What even is your argument? Real men write asm?

Sure, we can write a binary file format parser in C. We just can't figure out how to write one that isn't buggy and lets someone infect your computer if you give it sufficiently inventive garbage.

The issue isn't whether it's possible to have parsers, but whether it's possible to have them be secure, and periodic CVEs "everywhere" suggest we don't

Aside from memory safety, which is solved by using a compiler that just doesn't allow unsafe memory operations (so not GCC or Clang upstream), which CVEs specifically would have been ameliorated by a parser written in Rust instead of C?

Aside from the fact that it's not solved by using an alternative compiler, why would you put the core advantage aside?

What?

> Aside from memory safety, which is solved by using a compiler that just doesn't allow unsafe memory operations

I don't see how that's possible without turning the language into something that isn't C, either by adding significant new functionality (e.g. fat pointers) or subtracting enough functionality that it's a much less capable language (e.g. disallowing dynamic memory allocation).

Behold: https://fil-c.org/

An important improvement over rust is that "Fil-C has no unsafe statement."

As everything, there are compromises and prices to pay.

In case of fil-c, it is about 1.5-4x slower performance, and a memory overhead.

So, let's not present it as a panacea to all problems: there could good reasons to use it, but it isn't a magic trick.

Rust is slower too, and git is IO bound anyway, and routinely calls bash.

Rust is not 1.5-4x slower at all. Git is not IO bound at all, it is not saturating your IO device, it just performs IO a lot.

fwiw, the use of C is infinitely more "coerced" than the use of Rust.

on my Linux system, C takes ownership of a 'top-level' /usr/include directory, all the kernel APIs have their canonical definitions in C headers, a lot of system features like nsswitch require dynamically linked C libraries etc. etc.

Rust is just something that programs can choose to be written in and that doesn't inconvenience me in any way.

It doesn't need to be that way: https://gobolinux.org/at_a_glance.html

Of the codebases i know that have adopted Rust, it has always been because some of their maintainers wanted to do so.

Maybe git's case is different though. Do you have more info about it? Are you a git maintainer who was coerced to use Rust, or do you know of such cases?

I don't think it's "just for the sake of it". I think they believe that the Rust code will be safer.

> Having 0.1% of the code in a safe language will not change anything, it's only a bad security blanket.

Just because something does provide an immediate perfect solution does not mean it isn't not worth investigating and/or pursuing.

Also consider that bugs tend to be more prevalent in new code (e.g., [0]) as a result, you are likely to see more of a benefit from writing new code in a memory-safe language than raw line count proportions would indicate.

[0]: https://security.googleblog.com/2024/09/eliminating-memory-s...

You don't believe in slowly and iteratively improving a codebase over time? Should git stick with its weird mishmash of C and perl and shell scripts forever, for tradition's sake, performance and maintainability be damned?

I don't understand your reasoning. Why should they quit git and Linux (and presumably all applications written in C) if they believe Rust is more secure than C?

It's the classic "Yet you participate in society. Curious!" response. You don't get dislike the current state of the world if you exists in it, apparently.

I hope you don't use seatbelts in your car, as they won't help you against a fire.

Is all use of Rust "coerced" and "forced on everyone", or is there a way to write things in it that makes sense?