Hasty Briefsbeta

All tags

rust

33 stories total

Bilingual

The Sword Juggling Fallacy
a day ago
- Sword juggling is simple to explain but difficult to perform safely, serving as an allegory for C programming.
- C is a simple language with a small standard, but programming in C is hard, especially for ensuring correctness.
- Pointers in C are simple in theory but complex in practice, requiring careful management of ownership, lifetime, and memory.
- Rust's complex reference semantics, lifetimes, and borrow checker make it easier to write correct code compared to C.
- Unsafe Rust is compared to juggling chainsaws, highlighting the risks of low-level memory manipulation.
Building Docs.rs
a day ago
- docs.rs hosts documentation for Rust packages by building them from source using cargo doc and rustdoc, which is resource-intensive and risky because build.rs can execute arbitrary code.
- The author, a Rust developer working on the rcc C compiler, encountered a frustrating issue where docs.rs links to specific versions and redirecting to the latest version used to go to the home page instead of preserving the current page.
- After a long-standing issue existed for about a year and a half, the author attempted to contribute but faced difficulties with the outdated Vagrant-based local development setup.
- The author wrote a Dockerfile for local development, which impressed the team and was subsequently adopted in production.
- After about a month of work, the original change was merged, and the author was invited to the docs.rs team.
- The author continues to contribute and thanks the community for support.
The intra-doc links saga
a day ago
- A developer spent four months working on 'intra-doc links' for rustdoc, allowing links to items by name.
- The feature will become stable in Rust 1.48.0, which is four weeks away.
- Manishearth and the developer co-authored a detailed blog post about intra-doc links on the official Rust blog.
- Discussion about the feature is happening on Hacker News and Lobste.rs.
&'borrow mut dyn FnMut(BrokenLink<'input>) -> CowStr<'input> and other valid rust programs
a day ago
- The article describes a lifetime-related bug when using a callback with pulldown-cmark's Parser::new_with_broken_link_callback, where the lifetimes are unnecessarily tied together, causing confusing errors like 'static lifetime requirement.
- The fix involves separating the lifetimes of the input and the borrow of the callback, as shown in the updated type signature.
- Additionally, there is a diagnostics bug in the Rust compiler where the error message states the same type must implement a trait that it already implements, causing confusion.
- The author also discusses the background of rustdoc hiding brackets in intra-doc links and the need for a reusable callback.
borrow-checker FAQs
a day ago
- To modify elements in a collection while also modifying the collection, use 'while let' instead of 'for' loop to avoid double mutable borrow.
- When using a closure that captures a struct with disjoint fields, explicitly capture the needed fields with 'let' statements to avoid moving the whole struct.
- Moving code into a separate function may cause compilation failures due to the compiler not recognizing disjoint fields or incorrect lifetimes; workaround by inlining or restructuring the struct.
- To use an iterator from a struct while needing mutable access to the struct, collect the iterator into a new collection first (e.g., Vec) to satisfy the borrow checker.
I'll Rust With You: the song
a day ago
- Niko Matsakis, co-lead of the Rust language team, published a song titled 'Edition: the song'.
- The author was inspired to sing a cover of 'I'll Rust With You' by Steam Powered Giraffe.
- The cover song has no actual connection to the Rust language besides its title; it was done purely for fun.
the rust project has a burnout problem
a day ago
- The Rust project faces a severe burnout problem, with many maintainers leaving or nearing burnout.
- Burnout follows a cycle: new contributors struggle to find mentors, take on heavy workloads, and feel personally responsible for project progress.
- Key burnout drivers include the belief that work won't get done without personal effort and the need to review everything to prevent mistakes.
- Contributors are advised to prioritize self-care, avoid unpaid overtime, and treat paid Rust work as a regular job.
- Team leads should rotate responsibilities, document burnout solutions, and ask why people leave to address cultural and organizational issues.
- The project should treat burnout as a priority, focusing on team growth and a healthy environment over technical issues.
the core of rust
a day ago
- Rust has a strong vision, similar to Uiua and Zig, with a smaller, cleaner language struggling inside.
- Learning Rust involves mastering many interwoven concepts simultaneously: first-class functions, enums, pattern matching, generics, traits, references, borrow checker, Send/Sync, and Iterators.
- A simple 20-line Rust file watcher program requires understanding closures, Result, generics, enums, pattern matching, iterators, Send/Sync, lifetimes, and move semantics.
- In contrast, an equivalent JavaScript program requires only first-class functions and nullability, highlighting Rust's complexity.
- Rust's interwoven design is intentional; features like enums with pattern matching, Result/Iterators with generics, and Send/Sync with borrow checker complement each other.
- The author refers to without.boats' concept of a 'smaller Rust'—a cohesive core of orthogonal features that compose well.
How to build and publish multi-platform Rust binaries via Github actions
a day ago
- Automated CI/CD pipeline for Textpod triggered on GitHub release creation.
- Builds Linux and Windows binaries using cross-compilation on ubuntu-latest.
- Builds macOS binaries for both Intel (x86_64) and ARM (aarch64) on macos-latest.
- Generates SHA256 checksums for all binary archives and attaches them to the release.
- Publishes the crate to crates.io using the katyo/publish-crates action, dependent on successful builds.
- Builds and pushes Docker images for amd64 and arm64 platforms to Docker Hub using docker/build-push-action.
- Docker images based on rust:alpine are roughly 10 MB in size.
- Pipeline runs in the background after release creation, populating release page with files.
Claude Code uses Bun written in Rust now
a day ago
- Jarred Sumner claimed Claude Code v2.1.181+ uses the Rust port of Bun, resulting in 10% faster startup on Linux.
- Evidence from strings command shows Bun v1.4.0 (a preview version) and 563 .rs source files embedded in Claude Code.
- The Rust version of Bun is now available as a canary release via `bun upgrade --canary`.
- A simple script can confirm the embedded Bun version by running `BUN_OPTIONS="--preload=/tmp/bun-version.ts" claude --version`.
- The commit updating Bun's version to 1.4.0 was made on May 17th, but hasn't been tagged in a stable release.
Memory Safety Absolutists
3 days ago
- The article discusses the claim that Rust is unsafe due to its 'unsafe' keyword, despite its drastically lower memory safety vulnerability density (0.2 per MLOC) compared to C/C++ (1000 per MLOC).
- Fil-C, a new technology, can make C/C++ code memory safe by using GC and InvisiCaps, but it has trade-offs like ABI incompatibility, potential slowdowns, and reliance on garbage collection.
- The author criticizes memory safety absolutists, especially Fil-C's creator and Zig's developer, who dismiss Rust as unsafe while promoting Fil-C, ignoring practical trade-offs and Rust's proven safety in real-world projects.
- A pragmatic approach is advocated: using Rust for programs that cannot adopt Fil-C (e.g., due to GC or ABI issues), and encouraging Fil-C for projects where its trade-offs are acceptable, rather than forcing a single solution.
- The author argues that memory safety absolutism should apply consistently, criticizing C/C++ and non-Fil Zig as much as Rust, and that preventing most issues in most programs is better than demanding perfection.
- Even with Fil-C turning vulnerabilities into crashes, the high crash rate from C/C++ code (1000 per MLOC) highlights that Rust's balance of safety and practicality is valuable for many use cases.
Implementing SEH in Rust and why you shouldn't do it
4 days ago
- SEH is Windows' exception handling model; x64/ARM64 use a table-based version.
- SEH is needed in Rust for safely accessing usermode memory in drivers and for continuable exceptions.
- Implementing SEH via LLVM is not feasible because Rust lacks inline LLVM support.
- Assembly approach using gas macros and __C_specific_handler works but requires careful label range management.
- Rust inline assembly can replicate SEH, but resource cleanup (Drop) is not automatically called on SEH exceptions.
- C++ with /EHa properly destructs objects during SEH; Rust's lack of this leads to resource leaks.
- Best practice: implement SEH wrappers in C++ with /EHa and call them from Rust.
Writing a Debugger from Scratch
4 days ago
- The author writes a debugger in Rust to learn the language and help others understand debugger internals.
- A debugger uses an event loop: attaches to a process, waits for debug events, and continues execution.
- On Windows, attach via DebugActiveProcess or CreateProcessW with DEBUG_ONLY_THIS_PROCESS flag.
- The event loop calls WaitForDebugEventEx to receive events and ContinueDebugEvent to resume the target.
- Debug events include CreateProcess, LoadDll, CreateThread, Exception, etc., each carrying specific data.
- The initial exception is the breakpoint from ntdll!LdrpDoDebuggerBreak triggered at process startup.
- Future posts will cover handling exceptions, breakpoints, stepping, and other advanced features.
On Strings in Rust
6 days ago
- Rust strings involve two main types: `str` (string slice) and `String` (owned string), both guaranteed to be UTF-8 encoded.
- `str` is a dynamically sized type (DST) behind a wide pointer, while `String` wraps a `Vec<u8>` and supports heap allocation and mutation.
- Deref coercion and dot operator semantics allow methods like `chars()` on `String` by automatically dereferencing to `str`.
- The `len()` method returns byte count, not character count, due to UTF-8 variable-length encoding.
- Operator overloading (e.g., `+` for concatenation) and trait implementations like `PartialEq` enable ergonomic string operations.
- In-place methods like `make_ascii_uppercase()` work on `&mut str` but cannot handle non-ASCII characters that change byte length.
- Other string types include `OsString`/`OsStr`, `CString`/`CStr`, and experimental `ByteString`/`Char` for specific use cases.
Extending Polars with Rust Expression Plugins
7 days ago
- fenic is a semantic DataFrame library using Polars as its core execution engine for AI/LLM pipelines over unstructured data.
- Standard Polars lacks needed text operations (chunking, prompt templating, jq, fuzzy matching, markdown/transcript parsing, rich type casts).
- Python UDFs are too slow, break composition, and have poor type handling for these operations.
- The solution was building nine Rust expression plugins via pyo3-polars, making them native Polars expressions.
- Plugins run in-engine over Arrow buffers, are vectorized, composable, and have declared output types.
- Output type declaration is critical and can be static, derived from input fields, or from keyword arguments.
- The elementwise flag enables parallelism and streaming; broadcasting is handled via Polars helpers.
- Zero-copy Arrow access is achieved through a custom ArrowToValue trait with recursion for nested types.
- Plugins return pl.Expr, allowing composition with native Polars operations in a single expression tree.
- The build uses maturin with a single Rust crate; plugins also export plain Python functions for validation.
Kittine, a custom language for Rust-powered web apps
7 days ago
- Kittine is a language layered on top of Rust and Leptos with far less syntax, compiling to real Rust components.
- It targets Leptos 0.7 and supports both CSR via Vite and SSR via cargo-leptos from the same source.
- No virtual DOM or virtual JS runtime; uses fine-grained reactive updates that directly update DOM nodes.
- Every language construct is compiler-verified, with real compilation tested against Leptos 0.7.
- Supports structs (litter), enums (breed), pattern matching (pounce), and traits (claw) with generic type parameters.
- Ecosystem includes a compiler, Vite plugin, SSR support, VS Code extension, formatter/linter, and package manager.
- Roadmap features a docs site, interactive playground, RSS/sitemap, and real download stats after public release.
- Installation requires building the compiler from source, then installing dependencies and running the dev server.
Meta Garbage Collection: Using OCaml's GC to GC Rust
8 days ago
- Soteria Rust, a symbolic execution tool, experienced quadratic slowdown due to its Tree Borrows aliasing model when handling loops.
- The fix leverages OCaml's garbage collector to automatically remove unreachable tree nodes, using weak references and periodic major collections.
- This change achieved linear execution time and up to 10x speedup on benchmarks, with only about 40 lines of code.
- The approach highlights the benefit of deeply integrating with the host language (OCaml) for complex memory management tasks.
Claude Code uses Bun written in Rust now
10 days ago
- Jarred Sumner announced Claude Code v2.1.181+ uses Rust port of Bun, speeding up Linux startup by 10% with little user notice.
- Evidence found in Claude Code installation shows Bun v1.4.0 (macOS arm64), a version not yet released on GitHub as of the text's date.
- Rust version of Bun is available as a canary release, and 563 Rust source files in Claude indicate it's running in production.
Battery packs: Let's talk about crates, baby
12 days ago
- Battery packs are curated sets of crates around common themes to help developers choose high-quality crates without extensive research.
- Anyone can create a battery pack by publishing a crate named X-battery-pack with dependencies as recommendations.
- Battery packs include dependencies, features, templates, and structured categories (e.g., 'pick at most one' or 'pick any number').
- They aim to address challenges like crate selection for new Rust adopters and foster interoperability and maintenance funding.
- Risks include potential overcrowding of packs, but they are designed to evolve and avoid stagnation in the ecosystem.
We're Building Postgres in Rust. Using the LLVM of Databases
12 days ago
- Turso is becoming the LLVM of databases, with SQLite as the first frontend and Postgres as the next.
- Turso is a modern rewrite of SQLite in Rust, featuring concurrent writes via MVCC, a rich type system, and self-updating materialized views.
- The project aims to build a Postgres-compatible database with a modern architecture, including embedded browser support and file-based operation.
- Turso uses a bytecode language (VDBE) and has demonstrated running Doom via this bytecode in a browser.
- The approach involves compiling Postgres SQL to Turso's bytecode, merging pgmicro into Turso as an official project.
- Turso is open-source with over 260 contributors, emphasizing reliability through rigorous testing methods.
- The FAQ addresses compatibility, server support, AI contributions, development pace, and extension handling via WASM.

firstprev0next

About|Login

rust

The Sword Juggling Fallacy

Building Docs.rs

The intra-doc links saga

&'borrow mut dyn FnMut(BrokenLink<'input>) -> CowStr<'input> and other valid rust programs

borrow-checker FAQs

I'll Rust With You: the song

the rust project has a burnout problem

the core of rust

How to build and publish multi-platform Rust binaries via Github actions

Claude Code uses Bun written in Rust now

Memory Safety Absolutists

Implementing SEH in Rust and why you shouldn't do it

Writing a Debugger from Scratch

On Strings in Rust

Extending Polars with Rust Expression Plugins

Kittine, a custom language for Rust-powered web apps

Meta Garbage Collection: Using OCaml's GC to GC Rust

Claude Code uses Bun written in Rust now

Battery packs: Let's talk about crates, baby

We're Building Postgres in Rust. Using the LLVM of Databases