Top all-time · #1093
Languages and Architecture
Personal blog · verdagon.dev · on HN as verdagonprogramming
Languages and Architecture is a personal blog at verdagon.dev about programming. Since 2022, 65 different Hacker News readers have linked it 188 times, most often “Vale's Memory Safety Strategy: Generational References and Regions”. It is still writing: the last post was on 2026-10-18, and you can follow it by feed.
Most-linked posts?
- Vale's Memory Safety Strategy: Generational References and Regions11 people · 17 mentions · first linked 2022-04-24
- Vale's Higher RAII, the pattern that saved me 5 hours in the 7DRL Challenge5 people · 10 mentions · first linked 2022-03-24
- Vale's Hybrid-Generational Memory5 people · 7 mentions · first linked 2022-04-05
- Chasing the Myth of Zero-Overhead Memory Safety4 people · 5 mentions · first linked 2023-06-20
- Borrow Checking, RC, GC, and the Eleven () Other Memory Safety Approaches4 people · 5 mentions · first linked 2024-04-24
- What Vale Taught Me About Linear Types, Borrowing, and Memory Safety4 people · 5 mentions · first linked 2023-06-01
- The Golden Spike, and Resurrecting the Vale(n) Programming Language4 people · 4 mentions · first linked 2026-09-17
- Heisenbugs: The most elusive bug. How to capture them with Perfect Replayability4 people · 4 mentions · first linked 2022-06-29
- Vale's First Prototype for Immutable Region Borrowing3 people · 4 mentions · first linked 2023-06-16
- Fearless FFI: Memory Safety, Safer Dependencies, Supply-Chain Attack Mitigation3 people · 4 mentions · first linked 2022-06-22
What Hacker News says?
I think there isn't enough research into languages with affine/linear typing (the property of some types that they can't be copied - which is partly what the borrow checker ensures in Rust). I'm super sold on it for enhancing safety. Vale with its "Higher RAII"[0] is the only other example I was aware of until seeing this. Rust is great but being an early adopter has made its usability imperfect in places. Combining…
Comment linking /blog/higher-raii-7drl
on “Dada, an experimental new programming language”Submitted Accidentally making a language, for an engine, for a game as a story · 356 points
HN discussionfyi, your links on that page to hybrid generational memory seem incorrect (i.e. 7 in the sidebar, but I think there was another). I'd not heard of vale, but after reading around a little looks very interesting. Nice job! [0] https://verdagon.dev/blog/hybrid-generational-memory
Comment linking /blog/hybrid-generational-memory
on “Accidentally making a language, for an engine, for a game”Submitted Borrow Checking, RC, GC, and the Eleven () Other Memory Safety Approaches as a story · 189 points
HN discussionIs this blog entry out of date? Or is this still a WIP? > Note that hybrid-generational-memory is not implemented yet, it's still just a design. From https://verdagon.dev/blog/hybrid-generational-memory
Comment linking /blog/hybrid-generational-memory
on “Accidentally making a language, for an engine, for a game”Submitted Valen's Memory Safety: A New Kind of Borrow Checking as a story · 184 points
HN discussionThank you! We're pretty excited about it too. Though, I do want to be clear for readers, Seamless Concurrency [0] isn't fully implemented yet, we've only just started to play with its first building block, the region borrow checker. It's promising, but I don't want to get anyone's hopes up too early. [0] https://verdagon.dev/blog/seamless-fearless-structured-concu...
Comment linking /blog/seamless-fearless-structured-concurrency
on “Accidentally making a language, for an engine, for a game”Submitted Borrow Checking, RC, GC, and Eleven Other Memory Safety Approaches as a story · 184 points
HN discussionAlways a pleasant surprise to be scrolling through HN and seeing one of my articles on the front page! For anyone interested in how that code would get zero memory safety overhead without the classic borrow checker, a big part of it is because of the "region borrow checker" [0]. There are some other factors (iso regions, hybrid-generational-memory, etc.) but region borrow checking is the big one. [0] https://verdago…
Comment linking /blog/zero-cost-refs-regions
on “Accidentally making a language, for an engine, for a game”Submitted A new way to think about borrow checking (in reverse) as a story · 132 points
HN discussionNot staticassertion, but I'm a hobbyist in real-time audio. I like Rust as a vocabulary for describing/teaching safe programming (&/&mut/Send/Sync). I find that multithreaded programs written in Rust are usually correct while multithreaded programs written in C++ are usually wrong, because Rust encodes the rules of shared-memory threading in its type system (&T: Sync objects are thread-shared, but are either immutab…
Comment linking /blog/generational-references
on “The Hare programming language”Submitted Crossing the impossible FFI boundary, and my gradual descent into madness as a story · 106 points
HN discussionSome possibly relevant works: Pony has a separate GC for every actor. I suspect that in practice, these work a lot like arenas; since they're very short lived, I'd imagine that most actors just allocate a lot and then blast it away. [0] Odin (not GC'd) has an implicit "context" that has an allocator, [1] effectively decoupling the allocator from the code. One could use an arena allocator for any function they'd like…
Comment linking /blog/zero-cost-refs-regions
on “Chris Lattner on garbage collection vs. Automatic Reference Counting (2017)”Submitted Higher RAII and the seven arcane uses of linear types as a story · 99 points
HN discussionIronically, even though I believe RC will make great strides, I actually agree with you. Single ownership has the most potential, especially if we decouple it from the borrow checker as we are in Vale. [0] Being able to control when something is deallocated is quite powerful, especially for real-time systems. [0] https://verdagon.dev/blog/generational-references
Comment linking /blog/generational-references
on “Chris Lattner on garbage collection vs. Automatic Reference Counting (2017)”Submitted Group Borrowing: Zero-cost memory safety with fewer restrictions as a story · 85 points
HN discussionI'm not sure most people use this technique, but when I was using RC-based systems, I would often assert that an object's refcount was 1 just before I let go of that last reference. Suddenly, we have RAII-like predictable destruction. I even built it into Vale as one of its memory management options called "constraint references" [0] though later switched to generational references which gave us RAII without the hal…
Comment linking /blog/raii-next-steps
on “Chris Lattner on garbage collection vs. Automatic Reference Counting (2017)”Submitted Data races in Python, despite the Global Interpreter Lock as a story · 85 points
HN discussionA valid question, happy to enlighten! To get the automatic threading speed improvements, a (region-aware) language might add a `parallel` keyword in front of loops, to temporarily freeze pre-existing memory, thus completely eliminating the overhead to access it. Vale is building this for its generational references [0] model but I hope that more RC-based languages attempt something like it. Can't get much easier tha…
Comment linking /blog/seamless-fearless-structured-concurrency
on “Chris Lattner on garbage collection vs. Automatic Reference Counting (2017)”Submitted The Impossible Optimization, and the Metaprogramming to Achieve It as a story · 73 points
HN discussionDefinitely! Vale, Lobster, and Cone all require explicit annotations for anything that could cross thread boundaries. Vale's design bends the rules a little bit, it blends structured concurrency with region borrow checking to allow things to temporarily escape the current thread. [0] I believe Lobster spawns a new VM per thread, and has some special abilities to share data between them, but I'm vague on the details.…
Comment linking /blog/seamless-fearless-structured-concurrency
on “Chris Lattner on garbage collection vs. Automatic Reference Counting (2017)”Submitted On removing let and let mut as a story · 33 points
HN discussionI develop languages full time, and it's clear to me that RC will make massive strides forward in the next decade, for a few reasons: 1. First-class regions allow us to skip a surprising amount of RC overhead. [0] 2. There are entire new fields of static analysis coming out, such as in Lobster which does something like an automatic borrow checker. [1] 3. For immutable data, a lot of options open up, such as the stati…
Comment linking /blog/zero-cost-refs-regions
on “Chris Lattner on garbage collection vs. Automatic Reference Counting (2017)”Submitted Hash Codes, Non-Determinism, and Other Eldritch Horrors as a story · 31 points
HN discussion> The state of the application can be partitioned in separate components (called automata) that do not share any mutable state and can be safely updated concurrently. This is the right direction! Pure computations on (somewhat) centralized data has proven to be very resilient to bugs. It's kind of like how React organizes its programs. I like how Cell is tackling this problem at the language level. A language's prog…
Comment linking /blog/perfect-replayability-prototyped
on “Cell Lang: Why yet another programming language?”Submitted Vale's First Prototype for Immutable Region Borrowing as a story · 30 points
HN discussionThat sounds like the "generation" tag in Vale's generational references [0] or like how memory tagging works on ARM CPUs [1]. I love the approach, it's a way to get a lot more memory safety while not giving up a program's flexibility, especially in C's case. Some languages are opting to disallow pointer arithmetic and conversion between integers and pointers. We'll see how it works out! [0] https://verdagon.dev/blog…
Comment linking /blog/generational-references
on “Linear Address Spaces: Unsafe at any speed”Submitted When to use memory safe languages as a story · 27 points
HN discussionThe linear address space is the root reason why any language with FFI support will be inherently unsafe, unfortunately. Any errant pointer from C can accidentally (or intentionally) corrupt objects in the safe language. It's a difficult problem to solve. Vale's "Fearless FFI" designs [0] says we could sandbox entire third-party libraries using a WebAssembly compilation step, which might work well. Sometimes I wonder…
Comment linking /blog/fearless-ffi
on “Linear Address Spaces: Unsafe at any speed”Submitted The Golden Spike, and Resurrecting the Vale(n) Programming Language as a story · 14 points
HN discussion
