[0] https://vale.dev
The simplicity is particularly important. We've almost certainly surpassed the complexity limit in languages like C++, Rust, and Haskell. Each of these can be easier with time, but even past the learning curve they can impose a lot of artificial complexity.
It's also interesting that a lot of languages adopting subsets of Rust's model:
* Val is using unique references for its data, and not including shared references.
* HVM is using shared reference borrowing and implicit .clone()s for its data, and not including unique references. [0]
* Vale is using the borrow checker at a higher "region" level to make it opt-in, and using generational references which were inspired by Rust slotmap / generational indices. [1] (disclaimer: am Vale lead)
* Lobster is using implicit borrow checking for the simpler cases, and falling back to reference counting everywhere else. [2]
* Cone is using borrow checking on top of garbage collection, reference counting, single ownership, and any other user-defined memory strategy. [3]
Just as Haskell (and FP languages before it) showed us how far we can take immutability and what interesting patterns might emerge, I think Rust shows us what happens when you try to apply aliasability-xor-mutability to every problem. And just as how a lot of languages are adopting the good parts of Haskell, a lot of language's are adopting the good parts of Rust.
I hope Val goes far!
Also, I love their name. I tend to like languages that have the V and L sounds in them, though I might be uniquely biased ;)
[0] https://github.com/Kindelia/HVM
[1] https://verdagon.dev/blog/generational-references
[2] https://aardappel.github.io/lobster/memory_management.html
