verona VS ante

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

Have you had a look at Ante? It looks a lot like a Rust 2.0 with better ergonomics. There are a lot of interesting ideas.

Ante is what you are looking for. It's an ML descendant with no RTS nor AGC.

In my experience, people believe that programming languages are a solved space, and we should stick with what we have.

It's unfortunate; because languages are very polarized today. I think there's a lot of room for languages that are safe, fast, and most importantly, *easy.* Today's languages are generally two out of three.

Luckily, a lot of languages are exploring that space!

* Vale is blending generational references with regions, to have memory-safe single ownership without garbage collection or a borrow checker. [0]

* Cone is adding a borrow checker on top of GC, RC, single ownership, and even custom user allocators. [1]

* Lobster found a way to add borrow-checker-like static analysis to reference counting. [2]

* HVM is using borrowing and cloning under the hood to make pure functional programming ridiculously fast. [3]

* Ante is using lifetime inference and algebraic effects to make programs faster and more flexible. [4]

* D is adding a borrow checker!

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

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

[2] https://www.strlen.com/lobster/

[3] https://github.com/Kindelia/HVM

[4] https://antelang.org/