Why would we need rust, if the AI can just write really good code in C that doesn't exhibit any of the issues that rust protects you from?
Nobody who works with LLM generated code believes that LLMs produce fault-free code.
Its languages like C that you have to watch out for, because the LLM will gladly say "this is safe!" when its not.
My point, which I should have been clearer with, is that we aren't at a state where you can just one shot a rewrite of a complex application into another language and expect some sort of free savings. Once we are at that state, and it's good enough to pull it off, why wouldn't the AI be able to pull it off in C as well?
let foo = [1, 2, 3];
unsafe {
*foo.get_unchecked_mut(4) = 5;
}
> impossible to express in Rust
I’m not going to argue with Rust folks who misrepresent the language.
A lot of people are very excited by the idea that now language capabilities (and almost every other technical nuance) somehow don't matter but much like gravity they will continue to assert themselves whether you believe in them or not.
So far humans have proven unable to write large apps in C without those issues, given their work is the training basis for LLMs this creates two problems, one being that they don't 'know' what a safe app looks like either and any humans reviewing the outputted code will be unable to validate that either.
Now that the work is delegated to an LLM, the test and documentation quality ultimately decides the quality of the product.
Since you as the programmer no longer have to deal with the language's annoyances directly and force the LLM to perform the drudgery for you, you can build a language that makes a trade off between drudgery and quality and receive a software quality upgrade essentially for free.
LLMs are really good at producing tokens faster than developers, so make those tokens count.
"if"
If it could you wouldn't need to use Rust. It can't, qed.
I would not describe median quality C code as free from these issues
Rust gives you a lot of pain (= useful signals), before damage occurs.
Now imagine you build a reinforcement learning harness around Rust and C. Which is better for reinforcement learning? Impossible to detect failures in the final product or loud and annoying compiler errors that force you to address them?
In like 4 hours. (and most of that was me copy pasting things around to feed it reasonable chunks of information, feature by feature)
It also wrote a real-time passive DTLS-SRTP decryptor in C in like 1 hour total based on just the DTLS-SRTP RFC and a sample code of how I write suckless things in C.
I mean people can believe whatever they want. But I believe LLMs can write a reasonably fine C.
I believe that coding LLMs are particularly nice for people who are into C and suckless.