Vale retweeted
Just posted a new article! verdagon.dev/blog/group-borr…
"Group Borrowing: Zero-Cost Memory Safety with Fewer Restrictions"
TL;DR: Nick Smith's epic approach to better borrow checking. Take a look!
With this, new languages like Vale are one step closer to being able to reuse the entire Rust ecosystem!
verdagon.dev/blog/exploring-…
"Crossing the Impossible FFI Boundary, and My Gradual Descent Into Madness"
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!
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.
New article! "Borrow checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches"
verdagon.dev/grimoire/grimoi…
If anyone knows any more approaches, speak up, would love to expand that list!
Vale retweeted
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!
Vale retweeted
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.
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.
Vale retweeted
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-…
How to make a language like C++ memory-safe without borrow checking, RC, or tracing GC. Enjoy!
verdagon.dev/blog/vale-memor…
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-…
Vale retweeted
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!
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!
One of those little weird little language details that can have potentially *huge* development time benefits: generics and type erasure.
verdagon.dev/blog/generics-c…
Vale retweeted
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.
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.
There's a *lot* that goes on under the hood for Vale's region borrowing. But hey, nobody said it would be easy to make a completely new memory safety paradigm!
verdagon.dev/blog/making-reg…
The Vale compiler just passed 100,000 lines!
Some lessons learned from the endeavor so far: verdagon.dev/blog/first-100k…
An analysis of why GC is so fast to develop with, why borrow checking is often slower, and everything in-between. Enjoy!
verdagon.dev/blog/when-to-us…
"How Memory Safety Approaches Speed Up and Slow Down Development Velocity"
A tale of how a 2am realization led to discovering the fourth memory safety paradigm!
verdagon.dev/blog/making-reg…