verona VS tour_of_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

https://tourofrust.com/ is fun. Learning rust has a weird initial learning curve dealing with the aggressive analyzer/compiler and how you have to approach your variables, but after that initial hump it is one of the coziest languages I've used. Having what was initially a bit of a nag, is now a godsend when i'm getting red-squiggles in vscode for a typo in my SQL string for a misnamed column, or a field in my template was removed and so my struct shows how it's now unused.

1. 👶 Tour of Rust is a step-by-step guide for the Rust programming language. It gives a nice overview of the language and allows the learner to also modify the code examples to experiment.

Another good learning resource is the Tour of Rust, which is more hands-on than The Book. It has a code example (which you can edit and run directly) in every section.

The bonus by learning this way is that the Rust compiler gives amazing feedback allowing you to intentionally experiment by breaking the examples. https://tourofrust.com/ was my first superficial pass.

Tour of Rust - Richard Anaya

Other languages have similar ones like https://tourofrust.com/

1. Tour of Rust is a step-by-step guide for the Rust programming language. It gives a nice overview of the language and allows the learner to also modify the code examples to experiment. I would say that the Tour of Rust is not a resource that you would rely on by itself.

I really liked https://tourofrust.com/ Helped me a ton.