I'm pretty excited by what Val is doing. I feel like this is the next step in languages: finding a way to combine the techniques of the last decade (Pony's unique references, Rust's borrow checking, etc.) in new and interesting ways, to get closer to the ultimate goal: a language that has speed, safety, and simplicity.<p>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.<p>It's also interesting that a lot of languages adopting subsets of Rust's model:<p>* Val is using unique references for its data, and not including shared references.<p>* HVM is using shared reference borrowing and implicit .clone()s for its data, and not including unique references. [0]<p>* 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)<p>* Lobster is using implicit borrow checking for the simpler cases, and falling back to reference counting everywhere else. [2]<p>* Cone is using borrow checking on top of garbage collection, reference counting, single ownership, and any other user-defined memory strategy. [3]<p>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.<p>I hope Val goes far!<p>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 ;)<p>[0] <a href="https://github.com/Kindelia/HVM" rel="nofollow">https://github.com/Kindelia/HVM</a><p>[1] <a href="https://verdagon.dev/blog/generational-references" rel="nofollow">https://verdagon.dev/blog/generational-references</a><p>[2] <a href="https://aardappel.github.io/lobster/memory_management.html" rel="nofollow">https://aardappel.github.io/lobster/memory_management.html</a><p>[3] <a href="https://cone.jondgoodwin.com/" rel="nofollow">https://cone.jondgoodwin.com/</a>
Not to be confused with Val<i>e</i> (which is referenced in the article) [0], which also seems to be doing something similar.<p>[0] <a href="https://vale.dev" rel="nofollow">https://vale.dev</a>