crubit VS verona

See also:

Thomas Neumann's current proposal for memory safe C++ using dependency tracking:

- https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p27...

Google's proposal for memory safety using Rust-like lifetime analysis:

- https://discourse.llvm.org/t/rfc-lifetime-annotations-for-c/...

- https://github.com/google/crubit/tree/main/lifetime_analysis

For the people who are curious: crubit is an attempt to develop the way to seamlessly integrate C++ and Rust.

Please see the experimentation and proposals at https://github.com/google/crubit/blob/main/docs/lifetime_annotations_cpp.md and https://github.com/google/crubit/blob/main/docs/lifetimes_static_analysis.md

autocxx is good, though crubit is aiming for direct bidirectional interop

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

This language was started by folks at Google. (Although it's interesting that they're publishing it under a separate github org, which suggests ambitions beyond Google's needs.) Google has a huge, performance-sensitive C++ codebase. At Google, major product teams' backends are typically written in C++, as well as common infrastructure like D (disk server), Colossus (distributed filesystem), Spanner (distributed SQL database), and Borg (cluster management). More than a few people would love for it all to be be written in Rust instead, but migration would be challenging, to say the least. I'm told people are looking into it—see Crubit for example. But AFAIK, no one's decided yet whether Google will stay with C++ for all these things, migrate some to Rust, migrate some to Carbon, and/or do something else entirely.

It's currently unclear if Rust can interop with C++ with high fidelity. For example https://docs.rs/moveit/latest/moveit/ and https://github.com/google/crubit/blob/main/rs_bindings_from_... provide functionality to use non-trivially relocatable C++ types from Rust.

According to this FAQ, snmalloc was designed for the Verona language:

https://microsoft.github.io/verona/faq.html

Unfortunately, I cannot find any significant code samples for Verona on the website or in the GitHub repo. There are a few types defined in a pretty low-level way:

https://github.com/microsoft/verona/tree/master/std/builtin

I think the future lies in figuring out how to get the benefits of that secret sauce, while mitigating or avoiding the downsides.

Like Boats said, the borrow checker works really well with data, but not so well with resources. I'd also add that it works well with data transformation, but struggles with abstraction, both the good and bad kind. It works well with tree-shaped data, but struggles with programs where the data has more intra-relationships.

So if we can design some paradigms that can harness Rust's borrow checker's benefits without its drawbacks, that could be pretty stellar. Some promising directions off the top of my head:

* Vale-style "region borrowing" [0] layered on top of a more flexible mutably-aliasing model, either involving single-threaded RC (like in Nim) generational references (like in Vale).

* Forty2 [1] or Verona [2] isolation, which let us choose between arenas and GC for isolated subgraphs. Combining that with some annotations could be a real home run. I think Cone [3] was going in this direction for a while.

* Val's simplified borrowing (mutable value semantics) combined with some form of mutable aliasing (this might sound familiar).

[0] https://verdagon.dev/blog/zero-cost-borrowing-regions-part-1... (am author)

[1] http://forty2.is/

[2] https://github.com/microsoft/verona

[3] https://cone.jondgoodwin.com/

Their approach lines up pretty well with how we do regions in Vale. [0]

Specifically, we consider the "spine" of a linked list to be in a separate "region" than the elements. This lets us freeze the spine, while keeping the elements mutable.

This mechanism is particularly promising because it likely means one can iterate over a collection with zero run-time overhead, without the normal restrictions of a more traditional Rust/Cyclone-like borrow checker. We'll know for sure when we finish part 3 (one-way isolation [1]); part 1 landed in the experimental branch only a few weeks ago.

The main difference between Vale and the paper's approach is that Vale doesn't assume that all elements are self-isolated fields, Vale allows references between elements and even references to the outside world. However, this does mean that Vale sometimes needs "region annotations", whereas the paper's system doesn't need any annotations at all, and that's a real strength of their method.

Other languages are experimenting with regions too, such as Forty2 [2] and Verona [3] though they're leaning more towards a garbage-collection-based approach.

Pretty exciting time for languages!

[0] https://verdagon.dev/blog/zero-cost-borrowing-regions-overvi...

[1] https://verdagon.dev/blog/zero-cost-borrowing-regions-part-3...

[2] http://forty2.is/

[3] https://github.com/microsoft/verona

Does this count? https://microsoft.github.io/verona/

What about new Rust that "Microsoft Research" trying to "explore" https://github.com/microsoft/verona/blob/master/docs/explore.md ?

Fun fact: the person who created Pony, Sylvan Clebsch, has been working on a Microsoft Research project called Verona. From it's README [0]:

> Project Verona is a research programming language to explore the concept of concurrent ownership. We are providing a new concurrency model that seamlessly integrates ownership.

https://github.com/microsoft/verona/tree/master