HVM1

erences. [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/

oundary to get more solid safety guarantees than Rust could. [2] * HVM did this for Haskell by looking at Rust's particular blend of borrowing and cloning, and making it happen automatically. [3] * Lobster did something similar for an imperative mutable language, to reduce RC costs lower than ever before. [4] I think Rust is an amazing first attempt at an interesting new problem space, and a huge step forward for the field. Now, language designers are starting to notice that the building blocks that Rust trailblazed might be combined in new interesting ways, to make new interesting languages. It's an exciting time for programming languages! [0] https://kristoff.it/blog/zig-colorblind-async-await/ [1] https://verdagon.dev/blog/generational-references [2] https://vale.dev/memory-safe [3] https://github.com/Kindelia/HVM [4] https://www.strlen.com/lobster/

fast. [3] * Ante is using lifetime inference and algebraic effects to make programs faster and more flexible. [4] * D is adding a borrow checker! [5] [0] https://vale.dev/ [1] https://cone.jondgoodwin.com/ [2] https://www.strlen.com/lobster/ [3] https://github.com/Kindelia/HVM [4] https://antelang.org/ [5] https://dlang.org/blog/2022/06/21/dip1000-memory-safety-in-a...

r semantics and falls back to clone. It's not shared mutability, but Haskell without GC is pretty cool! https://github.com/Kindelia/HVM I particularly like D's approach because it's opt-in; we can use it in the areas of the program where we need performance the most, and prioritize flexibility and development velocity everywhere else, which I think is the right balance for most programs developed today. It also means one can gradually ease into learning how to use static analysis and their more complex constructs (like return scope, mentioned in the article). One can be proficient in the basic language quickly, and then improve their craft gradually. In modern software engineering, this is a big win, in my opinion. Props to D for going this direction!

ting idea I've wanted to experiment with. (I'd imagined a more Factorio-like Puredata or Max/MSP. It's something that came to mind from having read about [3].) [1] https://ncatlab.org/nlab/show/reflexive+object [2] https://github.com/Kindelia/HVM/blob/master/HOW.md [3] https://100r.co/site/orca.html

gur.com/a/8NtnEa3. That always seems like the right choice to me. After all, it just returns the same result, faster. I could be wrong, though. In which case you think parallelism isn't the correct choice? Is it because you don't always want to use the entire CPU? Would love to hear your reasoning. > Like I get that it helps a lot if you’re doing multiplication with Church numerals… This isn't about multiplication with Church numerals. Don't you find it compelling to write binary addition as "increment N times" and have it be as efficient as the add-with-carry operation? Making mathematically elegant code fast matters, and HVM does that. See the overview [0] for instance. Also, this allows us to have all the "deforestation" optimizations that Haskell applies on List with hardcoded #rewrite pragmas, for any user-defined datatype, which is also quite useful. There are certainly many uses that I'm not creative enough to think of. [0] https://github.com/Kindelia/HVM/blob/master/HOW.md#bonus-abu...