Sean's Blog

Rust

November 14, 2025
Edit on GitHub

Rust is a statically and strongly typed systems programming language that enforces memory safety (without a garbage collector) through its ownership and borrowing model, while still being efficient in the ballpark of C or C++.

In safe Rust, the compiler prevents entire classes of bugs common in C or C++, such as use-after-free and most data races. It also forces explicit handling of optional values via Option instead of allowing null references. While this shifts many potential failures from runtime to compile time (in contrast with dynamic languages like Python or unsafe manual memory management in C) - Rust does not eliminate logic errors, panics or higher-level concurrency issues like deadlocks. These properties are the reason Rust has made its way into the Linux kernel.

Rust also shines through its ergnomic package manager cargo that provides a smooth developer UX. The only real downsides of Rust are its inherent complexity (slow compile speeds and huge compilation artifacts disk size), still allowing unsafe code blocks and often verbose / ugly syntax.

Great introduction: https://fasterthanli.me/articles/a-half-hour-to-learn-rust

Borrow-Checker

A useful way to visualize Rust’s borrow checker is as a graph of ownership and temporary access. A value has one owner, while references create temporary edges pointing to that value. Ownership can move from one variable to another, but it is not duplicated unless you explicitly copy or clone the value. Borrowing means “I want access to this value without taking ownership of it,” and Rust checks that every reference remains valid for as long as it is used.

Allowed:                    Allowed:
   value                       value
  ▲  ▲  ▲                        ▲
  │  │  │                        │
 &a &b &c                     &mut x
 N readers                    1 writer

The key rule is many readers or one writer. Rust permits any number of immutable references (&T) at the same time, but if an exclusive mutable reference (&mut T) exists, no other readable or writable reference may overlap with it. You can think of this as a compile-time read/write lock. The borrow checker ensures that conflicting borrows are never active simultaneously and that no reference outlives the value it points to. This is useful even in single-threaded programs, and it also forms an important foundation for Rust’s prevention of data races in concurrent code.

The borrow-checker enforces this pattern for a variable:
many readers → one writer → many readers → one writer → ...

Allowed (N readers finish, then a single writer):

let mut x = 10;

let a = &x;
let b = &x;
println!("{a} {b}"); // last use of a and b

let w = &mut x;
*w += 1;                 // exclusive writer

This is rejected because the reader is still needed after the writer is created:

let mut x = 10;

let r = &x;
let w = &mut x;      // error: conflicting borrow (r is used after writer w)

*w += 1;
println!("{r}");         // r is still needed here

Crates

HTTP Server

Machine Learning

GUI

Text Extraction

Text Chunking

Concurrency

  • cineyma: Erlang inspired OTP-style actor framework
  • asupersync: Async runtime for Rust where correctness is structural: region-owned tasks, cancel-correct protocols, capability-gated effects, and deterministic replay testing

Coding Agents

References

#coding