verona

Verona is a research language: https://github.com/microsoft/verona/blob/master/docs/faq.md

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 would love a language (or C++ subset!) where we could get the benefits of that secret sauce, while mitigating or avoiding some of its downsides. Like Boats said, the borrow checker works really well with data, but not so well with resources. I'd also opine that it works well with data transformation but struggles with abstraction (both the good and bad kinds), works well with tree-shaped data but struggles with programs where the data has more intra-relationships (like GUIs and more complex games), and works well for imposing/upholding constraints but can struggle with prototyping and iterating. These are a nice tradeoff already, but if we can design some paradigms that can harness the benefits without its particular struggles, that would be pretty stellar. One promising meta-direction is to find ways to compose borrowing with mutable a

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 its own private "region", separate from the elements' region. This lets us freeze the spine region, while keeping the elements region 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 about this iterating benefit for sure when we finish part 3 (one-way isolation [1]); part 1 landed in the experimental branch only a couple weeks ago [2]. The main difference between the two approaches is that Vale doesn't assume that all elements are self-isolated fields, it allows references between elements and even references to the outside

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. [0] https://github.com/microsoft/verona/tree/master

Microsoft's Verona language is an interesting point in this design space--it allows references to be scoped to arbitrary heap regions: https://github.com/microsoft/verona/blob/master/docs/explore.... You can have arbitrary aliasing within a region, but the type system ensures that inter-region references obey lifetime rules. In a language like Verona, ParsedFile could have a contents Vec allocated in the same region as the ParsedFile, and a words Vec containing references into the contents Vec. Reference-typed fields by default are constrained to the same region as the parent object, so the above example works straightforwardly. The downside of this is that, in the general case, you have to garbage collect the regions. You can partition the heap using regions but all the same problems apply to the partitioned heap. NB: Rust uses the term

It is a discontinuous improvement: https://en.wikipedia.org/wiki/SPARK_(programming_language) https://www.rust-lang.org/ https://github.com/microsoft/verona/blob/master/docs/faq.md https://plantuml.com https://en.wikipedia.org/wiki/Infrastructure_as_code

It's not called out on the web page but the novel concept here is the usage of regions for memory safety. Microsoft's Verona[0] is also taking this approach. People seem to really like Rust but it's important to keep experimenting and see if we can get the same benefits but with better ergonomics. 0 - https://github.com/microsoft/verona/blob/master/docs/explore...

Verona has been exploring the idea of "behavior-oriented programming" as compared to "actor-oriented" like we have in Pony. Verona's model allows for something along the lines of what is being suggested. How that works out in the long run, we'll see. It's still very early days for Verona. A number of folks working on Pony also are associated with Verona and vice-versa so there's a cross-polination of ideas going on. https://github.com/microsoft/verona In particular see: https://github.com/microsoft/verona/blob/master/docs/explore... and https://github.com/microsoft/verona/blob/master/docs/explore...

Microsoft has Rust bindings for WinRT and I think some internal tools at Azure. But Microsoft has a long history of creating programming languages for every niche, so they'll probably make one in the tradition of Rust. https://github.com/microsoft/verona

If they want to use Rust, and have more faith in it than their own Verona[1], then they should discontinue Verona dev and let those developers go back to Pony[2]. I imagine having their core team working on Verona full-time is considerably delaying Pony development. [1] - https://github.com/microsoft/verona [2] - https://github.com/ponylang/ponyc (edit: formatting)

As much as I appreciate what Microsoft is doing here, your NIH praise is not entirely well targeted - look at this research project from Microsoft, which aims to build a slightly different Rust. https://github.com/microsoft/verona

There's also Project Verona [0], a research project inspired by Rust, Cyclone and Pony. [0]: https://github.com/microsoft/verona