verona VS PurefunctionPipelineDataflow

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

Implement relational data model and programming based on hash-map (NoSQL)

The Math-based Grand Unified Programming Theory: The Pure Function Pipeline Data Flow with Principle-based Warehouse/Workshop Model

I criticized "AMD Infinity Fabric Architecture" at the end of my article "Prediction: Intel will use "RISC-V plus x86 compatibility layer" or "RISC-V plus x86 heterogeneous computing architecture" to develop a new generation of "warehouse/workshop model" CPU".

What's more, you're being somewhat liberal with your "invention" dates here anyway. I'm sure you realize that anyone can review the commit history to see when content was added to the repo. As of Nov 2020, the day Apple announced a fully operational and tested, ready-to-ship silicon package the repo was a just series of bullet points listing out well-known concepts of functional programming sprinkled with some religious analogies and inspirational quotes. The farther you go back in the repo commit history, the less content is there.