Vale VS autocxx

Not to be confused with Vale[0].

[0] https://vale.dev/

The article says they created a deterministic hypervisor that runs all pseudorandom behavior from a starting seed to enable perfect re-playability.

But that's all we know so far. I'm assuming there'll be some sort of fuzz testing, and static analysis or some defining actions that your software can perform.

Honestly it sounds a lot like it has a lot of crossover with what the Vale language is trying to solve: https://vale.dev/, but focused on trying to get existing software to that state instead of creating a new language to make new software already be at that state by default.

Why go through all the trouble when you can do this: https://www.hylo-lang.org/ and not spend a second thinking of lifetimes? No, copies will not be issued unless necessary.

Or why not keep exploring this idea as well? More research-oriented than the first one right now, though, so take it with a grain of salt: https://vale.dev/

Another relevant language might be Vale (https://vale.dev), which is aiming for "perfect replayability": https://verdagon.dev/blog/perfect-replayability-prototyped

Interesting. Very low level though and C(++) centric. She there any thoughts on combining the hardware and OS features with rust or https://vale.dev ?

Use a runtime memory management solution that's cheaper than garbage collection (see Vale)

This seems like a tool I'll be using, and this is an almost meaningless criticism, but why the name?

There's already the Vale programming language (https://vale.dev/), but moreover, I don't get the meaning of "vale". You could call it something like Englint which actually hints its purpose.

Meanwhile, one of the best C++ sources which community mostly think of - Chromium - starting to experience with Rust. If i'm not mistaken using https://github.com/google/autocxx

There's bindgen, cxx and autocxx. Obviously not as convenient as C++ calling C++; the more you need to interoperate with C++ code the more it makes sense to just stay with C++.

If you want to reach the author for a correction, perhaps leave a comment on the Medium post or perhaps mention it on the autocxx PR I found this article from.

Rust and C++ are not directly interoperable, but you can try to use some fancy libraries if your C++ codebase is simple. Google is taking on this gargantuan task with autocxx. I believe it is related to their exploration efforts to bring Rust to Chrome.

I used autocxx in a recent project and was amazed at how easy it was to call into C++ -- Rust Analyzer was even able to provide completion hints.

Sure, they can improve C++ interop - and they have been - but that doesn't help them maintain the dozens of millions of lines of C++ they (Google, and others) currently have. Carbon is a pragmatic solution to the state of affairs in C++ that doesn't require them to rewrite all of their existing code to improve its maintainability.

The areas you mentioned (CLI, web services, low level systems programming) are not mutually exclusive. Doing a good job on one doesn't mean something else is affected.

The folks who worked on the most popular command line argument parser (https://docs.rs/clap/latest/clap/#example) made a positive contribution that didn't detract from any other use case.

Similarly, the folks working on improving Rust for web services will also make it better for systems programming. In a blog post published today (https://blog.rust-lang.org/inside-rust/2022/07/27/keyword-ge...), they discuss keyword generics, a feature that will be equally helpful for `async` code and `const` functions evaluated at compile time.

There is already some interoperability with C++ (http://cxx.rs) and ongoing research into automating this interoperability (https://github.com/google/autocxx, https://github.com/google/crubit). Feels like there's enough effort

That's not at all in Rust's bill, it needs an interaction layer to talk to C++. Efforts like cxx (and google's own autocxx) try to make this layer more automated and less painful, but the layer is still there, it still has a cost, and it doesn't erase the impedance mismatches between the languages.

Notably Google is also investing in autocxx to make C++/Rust bidirectional interoperation easier

Again, not really...? A lot of the proposed ABI changes (for C++ - I don't know what they're planning for Carbon) are trivial to automatically fix if you have source access. If you don't have source access, you "only" need to maintain the ABI at the boundaries between foreign code and your code, which is quite possible (especially after the success of autocxx and related projects in the Rust <-> C++ world)