Languages and Architecture

A blog on programming languages, software architecture, and Evan Ovadia's other shenanigans!
https://verdagon.dev/ (RSS)
visit blog
Crossing the Impossible FFI Boundary, and My Gradual Descent Into Madness
17 Jun 2024 | original ↗

Committing language interop sins for science June 17, 2024  —  Anyone trying to make a new mainstream language is completely insane, unless they're backed by a huge corporation.

Exploring Seamless Rust Interop for Newer Languages, Part 1
24 May 2024 | original ↗

Committing language interop sins for science May 24, 2024  —  Languages like C++, Typescript, Kotlin, and Swift had a brilliant approach: they were created to harness an existing ecosystem of libraries from another pre-existing language. But that's easier said than done!...

Higher RAII, and the Seven Arcane Uses of Linear Types
14 May 2024 | original ↗

Linear types + whitelisted destroyers = powers yet unimagined! May 14, 2024  —  Also posted today: Layer-wise inferencing + batching: Small VRAM doesn't limit LLM throughput anymore, on how even a normal small computer can now run...

Layer-wise inferencing + batching: Small VRAM doesn't limit LLM throughput anymore
14 May 2024 | original ↗

Also posted today: Higher RAII, and the Seven Arcane Uses of Linear Types, about how linear types let us control the future! Currently, the general consensus is that you can't really run larger LLMs on ordinary computers.

Borrow checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches
24 Apr 2024 | original ↗

The Memory Safety Grimoire, Part 1 April 24, 2024  —  A fellow named Zeke came into my server one day. Zeke: "Wait, so with generational references, we now have four ways to do memory safety?" Evan: "In fact, there are fourteen by my count....

Vale's First Prototype for Immutable Region Borrowing
11 Jul 2023 | original ↗

Results and measurements! July 11, 2023  —   —  Sponsor on GitHub or Patreon! Three...

Generational References (Expanded)
10 Jul 2023 | original ↗

Generational references are a memory management technique, an alternative to reference counting, tracing garbage collection, or borrow checking. 0 In this technique, every reference remembers the ID ("generation") of the object it's pointing at. If the user dereferences an object and Vale isn't certain it's still...

Making C++ Memory-Safe Without Borrow Checking, Reference Counting, or Tracing Garbage Collection
22 Jun 2023 | original ↗

Let's unleash some memory-safety mixed martial arts June 22, 2023  —  Adding memory safety to C++ is a very difficult problem, to say the least. I've spent most of the last decade exploring this area (mainly to design Vale's memory...

Single Ownership and Memory Safety without Borrow Checking, Reference Counting, or Garbage Collection
15 Jun 2023 | original ↗

this one simple trick language designers don't want you to know June 15, 2023  —  Single ownership is one of those concepts that's both easier and more powerful than we realize. People often think it's complex, because it most often appears in languages that are already complex for...

Chasing the Myth of Zero-Overhead Memory Safety (plus pictures of mythical birds!)
15 Jun 2023 | original ↗

In my recent article, I showed how Vale's linear types can provide memory safety without a borrow checker, generations, reference counting, or tracing GC. My friend Mike asked, "So linear types give zero-overhead memory safety, like borrow checking?" "Perhaps," I said. "What do you mean by zero-overhead...

The Link Between Generics, Compile Times, Type-Erasure, Cloud Building, and Hot-Code Reloading
9 Jun 2023 | original ↗

In the Unexpected Quest post, I talked about how we had to transition Vale's templates to full generics in order to implement Vale's region borrowing feature which blends borrowing with shared mutability. I wanted so badly to write...

What Vale Taught Me About Linear Types, Borrowing, and Memory Safety
1 Jun 2023 | original ↗

And some ancient egyptian hieroglyphic slates! June 1, 2023  —  I've had some pretty surreal experiences while making Vale. 0 The weirdest was when I realized the hidden fundamental truth beneath a lot of the programming...

An Unexpected Quest in Implementing Vale's Region Borrowing
9 May 2023 | original ↗

Generics help us avoid code size explosions! May 9, 2023  —  A few years ago, a 2am realization changed the course of my life forever, and eventually turned me into a nomadic hermit

How To Survive Your Project's First 100,000 Lines
2 May 2023 | original ↗

Stay on top of your testing In a small project, only a few thousand lines, it's easy to fix a bug without causing any more bugs because you know the system in and out. Once you start approaching 10,000 lines, fixing one bug will often cause multiple other bugs. Not just easy bugs, but obscure bugs that your users find six months...

How Memory Safety Approaches Speed Up and Slow Down Development Velocity
16 Jan 2023 | original ↗

Part 2 of the Memory Safety Expedition! Jan 16, 2023  —  Every March, developers worldwide each try to make a roguelike game in less than 168 hours as part of the 7DRL Challenge. Roguelike games are hard, involving procedural level generation, pathfinding,...

Implementing a New Memory Safety Approach, Part 1
22 Nov 2022 | original ↗

A new paradigm, for easy and flexible speed and safety! Nov 20, 2022  —  A few years ago, I was lying in bed at 2am listening to my favorite fanfiction podcast for the 47th time, drifting in and out of sleep, brain spinning on various features and bugs I'd...

Zero-Cost Memory Safety with Vale Regions (Preview)
16 Nov 2022 | original ↗

Watch regions eliminate memory safety overhead! Nov 14, 2022  —  Note: Regions are still a work-in-progress. Part 1 has been successfully prototyped, but parts 2-5 are only a preview describing...

Hash Codes, Non-Determinism, and Other Eldritch Horrors
9 Nov 2022 | original ↗

Until recent events, I've firmly believed the most terrifying thing known to mankind is the kraken. The kraken is a colossal eldritch sea horror which resembles a giant squid. It's known to crush entire ships. They say that 60% of all ships lost at sea fell victim to krakens, probably. 0

When to Use Memory Safe Languages, Part 1: Safety in Non-Memory-Safe Languages
7 Oct 2022 | original ↗

Part 1 of the Memory Safety Expedition Oct 8, 2022 — A few weeks ago, I was asked four questions all on the same day: "When would we use C-like languages?" "What language should I use for my game?" "Why don't more people use Rust for web servers?" "What are the benefits of borrow...

Perfect Replayability
28 Jun 2022 | original ↗

Overview In short, we eliminate all undefined behavior, remove as many sources of nondeterminism 3 as possible, and record the rest. Let's start with how we can record inputs! Recording Inputs We can start up our program in "recording mode",...

Vale's Fearless FFI, for Safer Dependencies and Supply-Chain Attack Mitigation
21 Jun 2022 | original ↗

Vale 0.2 is out, and it includes the beginnings of a feature we like to call Fearless FFI. This is part of Vale's goal to be the safest native language. 0 Most languages compromise memory safety in some way which can lead to difficult bugs and security...

Vale 0.2 Released: Higher RAII, Concept Functions, Const Generics, FFI, Modules, Faster Compiles, set Keyword
12 May 2022 | original ↗

Concept Functions Vale now supports concept functions, a way to specify that certain functions must exist for given generic parameters, without making them implement any traits. For example, List's clone function can require that there exists a clone function for its elements: func...

Added to Vale 0.2 Beta: Concept Functions
29 Apr 2022 | original ↗

Like traits, but way more straightforward!

Const Generics and the Compile Time Spread Operator
27 Apr 2022 | original ↗

A compile-time for-each operator!

On Removing Let and Let Mut
20 Apr 2022 | original ↗

So small a thing, yet such an improvement!

A Tale of Yak Shaving: Accidentally Making a Language, for an Engine, for a Game
4 Apr 2022 | original ↗

The longest yak-shave in history!

Surprising Weak-Ref Implementations: Swift, Obj-C, C++, Rust, and Vale
31 Mar 2022 | original ↗

Such shenanigans, right under our noses!

Vale's Higher RAII, the pattern that saved me a vital 5 hours in the 7DRL Challenge
22 Mar 2022 | original ↗

How a language can enforce that we call an arbitrary function before destroying an object.

Seamless, Fearless, and Structured Concurrency
21 Mar 2022 | original ↗

We can combine the best parts of different structured concurrency approaches!

Generational References
5 Jan 2021 | original ↗

2.3x faster than reference counting, unoptimized!

Vale's Hybrid-Generational Memory
2 Jan 2021 | original ↗

For speed and simplicity!

Zero-Cost References with Regions in Vale
29 Jul 2020 | original ↗

Watch regions eliminate reference-counting overhead!

The Next Steps for Single Ownership and RAII
15 Jul 2020 | original ↗

How constraint references enable easy safety, speed, and much more powerful RAII!

↑ these items are from RSS. Visit the blog itself at https://verdagon.dev/ to find other articles and to appreciate the author's digital home.