> ... from a programmer's perspective, I would love to see a mix of compile-time lifetime analysis, Automatic Reference Counting (like in the lobster programmin

> ... from a programmer's perspective, I would love to see a mix of compile-time lifetime analysis, Automatic Reference Counting (like in the lobster programming language), and manual memory management (marked as unsafe) for when extreme performance is needed. Surprisingly, such a thing is actually possible. We can use borrow-checker-like static analysis layered on top of shared mutability (such as RC). It involves selectively making certain sub-graphs ("regions") immutable, thus getting the borrow checker's zero-cost memory safety, without the architectural restrictions the borrow checker normally imposes. The core insight is that a borrow checker doesn't need every object to be completely affine, all it needs is some notion of what objects are reachable from what others. This has recently been prototyped in the research languages from Forty2 ("capsules") [0] and from Milano, Turcotti, Myers [1]. Pony's "iso" [2] has shown that it can work remarkably well in production, and Vale [3] is making it work with single ownership. In my (biased!) opinion, it's one of the most promising areas in language research. If we can get the speed and safety benefits of Rust while being more ergonomic and intuitive, I'd consider that a big step forward for the field. An exciting time to be in language design! [0] http://forty2.is/ http://forty2.is/ [1] https://www.cs.cornell.edu/andru/papers/gallifrey-types/gallifrey-types.pdf https://www.cs.cornell.edu/andru/papers/gallifrey-types/gall... [2] https://tutorial.ponylang.io/reference-capabilities/reference-capabilities.html#isolated-data-is-safe https://tutorial.ponylang.io/reference-capabilities/referenc... [3] https://verdagon.dev/blog/zero-cost-refs-regions https://verdagon.dev/blog/zero-cost-refs-regions