Bilingual

Ante: A new way to blend borrow checking and reference counting
a month ago
- Ante combines reference counting and borrow checking without runtime crashes, allowing flexible prototyping and gradual optimization.
- Unlike Rust's Rc with RefCell or Swift's borrowing system, Ante avoids runtime errors and overhead for mutable objects.
- Ante supports shared mutability with 'shared' types, enabling safe mutable borrows of reference-counted data via shape-stability.
- Unions in Ante require 'uniq' references for safe mutable access, with compile-time checks to prevent aliasing issues.
- Temporary 'uniq' conversions allow exclusive mutable references while restricting access to potentially aliasing variables.
- Ante's approach differs from Rust's Cell, which requires swapping values, by allowing direct mutable references to nested data.
- The compiler performs type analysis to ensure safety, though it may be brittle; future improvements aim for better ergonomics.
- Emerging patterns suggest shared mutable borrowing is possible, challenging traditional assumptions in memory safety design.
Evaluation order and nontermination in query languages
25 days ago
- λFS combines functional programming with relational programming, treating relations as finite functions.
- Nontermination in recursion introduces challenges with evaluation order and semantics.
- Three evaluation strategies discussed: left-to-right, nondeterministic, and parallel 'and'.
- Left-to-right evaluation offers predictability but may be inefficient for cyclic queries.
- Nondeterministic evaluation allows optimization but complicates compositional reasoning.
- Parallel 'and' restores determinism and symmetry but is difficult to implement efficiently.
Reducing Assumptions, Exploding Your Code
22 days ago
- Scripts often assume happy paths but need error handling for real-world imperfections.
- An example script downloads a PDF using an ID argument and API token, with error-prone assumptions.
- Adding basic validation in Python increases complexity and disrupts code flow, while Rye maintains structure.
- Full error handling in Python results in lengthy code, whereas Rye's design keeps it concise with failure as a normal value.
Notes on structured concurrency, or: Go statement considered harmful
11 days ago
- Concurrency APIs have traditionally used go statements (thread spawning, callbacks, futures) that allow background tasks to run independently, similar to goto statements in control flow.
- Go statements break abstraction by making functions non-black-box (they may spawn tasks without caller knowledge), disrupt automatic resource cleanup, and hinder proper error propagation.
- Trio introduces nurseries as a structured alternative, where tasks are started within a nursery block and the parent task waits for all child tasks to finish before exiting, ensuring control flow follows the 'black box' rule.
- Nurseries preserve function abstraction, support dynamic task spawning, allow explicit passing of nursery objects for flexibility, enable custom nursery-like types, and integrate automatic error propagation and cancellation.
- Removing go statements enables new features like reliable cancellation and proper control-C handling in Python, and nurseries encourage clearer, more robust concurrent programming, as demonstrated by simplified implementations like Happy Eyeballs in Trio.
Solod: Go can be a better C
13 days ago
- Solod (So) is a strict subset of Go that translates to regular C, supporting structs, methods, interfaces, slices, maps, multiple returns, and defer.
- Everything is stack-allocated by default, with heap allocation as an opt-in via the standard library. There is limited generics support, and concurrency is provided by the standard library instead of being built-in.
- So targets Go developers seeking systems-level control without learning a new language and C programmers who appreciate Go's safety, structure, and tooling.
- The example code demonstrates a simple Person struct with a method, and So features like time handling. Users can run or translate Go code to C through the provided interface.
- As of July 2026, So is in active development with release 0.2 adding networking, WebAssembly, and freestanding mode. Version 0.3 is planned for concurrency support.

Hasty Briefsbeta

programming-languages

Ante: A new way to blend borrow checking and reference counting

Evaluation order and nontermination in query languages

Reducing Assumptions, Exploding Your Code

Notes on structured concurrency, or: Go statement considered harmful

Solod: Go can be a better C