The Val Programming Language

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.

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

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

Not to be confused with Vale (which is referenced in the article) [0], which also seems to be doing something similar.

[0] https://vale.dev