[benreesman]

Having only glanced at the code I can’t offer much insight beyond “looks plausible”.

A far more important point is to address is that any FFI story with C++ that’s well executed is going to be great for the Rust ecosystem, and historically the community’s commitment to C++ interop has seemed tepid at best.

Even if one admits that Rust is strictly better than C++ for problems in the relevant domains, which seems an extraordinary claim that exceeds extraordinary evidence, there is still an ocean of C++ that we just can’t rewrite in even a decade, maybe not in a century.

There are use cases where Rust is just strictly a better choice: anything with an attack surface like a shell or an SSH daemon, or probably even a browser is an obvious candidate for a language with better reasoning about common attack vectors. I trust my Rust user land a lot more than my C userland.

But the “rewrite everything in Rust and push that via bad interop” is limiting the adoption of a cool language.

I’m a big fan of efforts to be more incremental.

[tialaramex]

> we just can’t rewrite in even a decade, maybe not in a century.

The former claim seems unlikely as stated ("cannot") but is at least plausible in practice ("will not"). The latter makes no sense. C++ didn't exist fifty years ago, so you're asking that we believe somehow C++ was so well suited to some unspecified problems that rewriting software in a better language will take more than twice as long.

[cgio]

Rebuilding existing features tends to be deprioritised against building new. In that sense, the process for rebuilding might indeed take longer, even if the new approach is faster to deliver (which in the case discussed probably is not) as it does not happen in vacuum but in parallel with other developments.

[wavemode]

Then you would agree that it is more "will not" than "cannot"

[gumby]

You are arguing a distinction without a difference. If socially one could not muster the will to do something then it will never happen -- it cannot be done.

We certainly could reduce the use of fossil fuels by over 90% in a few months -- global nuclear war would probably work -- but I hope nobody has the will to make that happen. Conversely we could reduce them by that much over a 30 year span, but currently lack the will. So in that case the distinction would make sense.

But few are willing to "replace this working thing for a small gain" (and you can argue about rust but when something works and the downside is a statistical risk demonstrably of low probability* ) it will be hard to find many people willing to invest in it.

Eventually these old programs will be replaced but they won't be replaced with functional equivalents, any more than, say, wired home phones were replaced with fibre optic connections. They will be replaced with something de novo instead.

* nerds like us may say the risk is significant but the level of uproar in security breaches is negligible in practice and the actual incidence of bugs due to things like use-after-free is likewise tiny.

[wavemode]

But... there is a difference. The difference is that it will not be done, rather than cannot be done. (Sort of self-explanatory, really.) They're different words, with different meanings, and different real-world consequences.

For example, if government regulations change, or the languages change, or engineering culture changes, or developers' desires and preferences change, suddenly "will not" becomes "will". But "cannot" is not so malleable.

[codetrotter]

I mean, there’s a lot of systems out there now that are so relied upon by other systems and people that you literally have to probably be bug for bug compatible with the existing system if you’re gonna have any chance of doing a rewrite of it in another language.

That kind of thing takes time. And all of that time spent is also time that you continuously will have to justify to the executives why exactly we are doing this rewrite again and why there have been 0 new features added to the system because everyone has been busy with the rewrite. Or you assign just part of the people to the rewrite and the rest of the teams continue adding features to the existing system, and now you have to constantly play catch-up. Or everyone is responsible for both rewriting and for adding features, and new features are added into the legacy code and then also written in the new language.

It’s possible. I’ve been on teams that successfully rewrote legacy software in Rust. But until it literally becomes something that directly impacts revenue in an indisputable way – say through fines imposed for security incidents and those incidents being due to memory safety – there’s still a lot of organizations that will completely refuse these kinds of rewrites no matter how good the evidence is that they should be doing so for many reasons.

[saghm]

> But the “rewrite everything in Rust and push that via bad interop” is limiting the adoption of a cool language.

For what it's worth, I've rarely heard "rewrite it in Rust" pushed by the most influential and productive members of the Rust ecosystem. I think the disparity here is that the people pushing the more extreme agenda aren't the same ones making major projects that people use, so it turns out that most of the stuff being made is for writing new software since that's what the people making it are interested in.