←
Vale33 posts
Vale avatar

Vale

@vale_pl

The Vale Programming Language! Learn more at vale.dev/

◷ Joined July 2020▧ 1 Photos and videos
Vale avatar
Vale@vale_pl·24 May 2024

If we're right, then this could pave the way towards newer languages calling into and building upon Rust, in the same way C++ built upon C! verdagon.dev/blog/exploring-… The most surprising part is that we're sending non-#[repr(C)]'d types into C. Heresy, but effective!

Vale avatar
Vale@vale_pl·14 May 2024

Behold! Higher RAII, and the Seven Arcane Uses of Linear Types: verdagon.dev/blog/higher-rai… It turns out, you unlock pretty sorcerous powers when you make it so only specific functions can destroy a certain type. Also, it's very weird that a language could help with caching.

Evan Ovadia avatar
⟳ Vale retweeted
Evan Ovadia@verdagon·11 Jul 2023

Regions are also a way to make colorless fearless structured concurrency (a mouthful I know), without going all in on a Rust-like borrow checker. verdagon.dev/blog/seamless-f… Now that we have a working regions prototype, I can finally start working on concurrency!

Evan Ovadia avatar
⟳ Vale retweeted
Evan Ovadia@verdagon·11 Jul 2023

This has been a long time coming! Regions are Vale's "killer feature", they let us write in a normal unrestricted way then incrementally optimize. This lets the user choose whether they their is flexible like Java, fast like Rust, or any point in between.

Vale avatar
Vale@vale_pl·11 Jul 2023

At long last, the first prototype of immutable region borrowing in Vale! verdagon.dev/blog/first-regi… This technique removes Vale's memory safety overhead by making borrowing and shared mutability work well together.

Evan Ovadia avatar
⟳ Vale retweeted
Evan Ovadia@verdagon·23 Jun 2023

Blend #2: Single-threaded RC (Nim), plus region borrowing (Vale) [1], plus copy types (C#, Swift). Enforced by static analysis checker, of course. (I think we might also be able to do contiguous ref-counted arrays, but still looking into that.) [1] verdagon.dev/blog/zero-cost-…

Vale avatar
Vale@vale_pl·19 Jun 2023

We often talk about zero-overhead memory safety, but no language has ever really achieved it. Once we use a more holistic definition, we see that memory safety always has a run-time cost. The only question is: where do we want to pay it? verdagon.dev/blog/myth-zero-…

Evan Ovadia avatar
⟳ Vale retweeted
Evan Ovadia@verdagon·15 Jun 2023

Linear types (and the higher RAII they enable) are pretty huge. Any time you say "Ah, I forgot to do X", that's a bug linear types help prevent. I wrote about this in verdagon.dev/blog/higher-rai… and have been discovering more and more uses for them ever since!

Vale avatar
Vale@vale_pl·15 Jun 2023

It turns out, one doesn't need borrow checking, RC, or GC to get memory safe single ownership! And with a little twist, we can enable compile-time guarantees that no mainstream language has been able to achieve. verdagon.dev/blog/single-own… Enjoy!

Evan Ovadia avatar
⟳ Vale retweeted
Evan Ovadia@verdagon·1 Jun 2023

Fun fact: All these techniques we're designing for Vale could easily be applied to reference counted languages too. This (plus regions) is why I think RC will make a huge comeback in the next decade, even over tracing GC.

Vale avatar
Vale@vale_pl·1 Jun 2023

Revelations about where efficient memory safety actually comes from! verdagon.dev/blog/linear-typ… TL;DR: We can combine linear types with other memory safety approaches (like gen refs or ref counting) to reduce overhead down to zero where we want.