Lightnews — Scholar-powered news

Reposted by Jérôme Gravel-Niquet

Mara Bos

@mara.bsky.social

#rustlang hot take: We should rename .unwrap() to .or_panic(). (And .expect() to .or_panic_with().) "Unwrap" is a terrible name for the panicking function, especially since we also have things like .unwrap_or() and .unwrap_or_default() which never panic.

November 19, 2025 at 7:32 AM

Reposted by Jérôme Gravel-Niquet

fjallrs.bsky.social

@fjallrs.bsky.social

3.0.0 pre.5 is out and brings journal compression support.

Here's 16K JSON blobs being written:

November 8, 2025 at 2:56 PM

Reposted by Jérôme Gravel-Niquet

fjallrs.bsky.social

@fjallrs.bsky.social

v3 pre-release 2 is out!

Still not file format -or API stable, but most importantly this release marks lsm-tree being *feature complete*.

crates.io/crates/fjall...

crates.io: Rust Package Registry

crates.io

October 28, 2025 at 10:15 PM

Reposted by Jérôme Gravel-Niquet

Antithesis.com

@antithesis.com

If you read one thing today, make it this blog post by our friends @fly.io. This is what tech writing should be like: witty, relatable, informative. Corrosion is a remarkable system, and we aren't just saying that because it was #TestedwithAntithesis.

❤️ y'all!

fly.io/blog/corrosi...

Deploy app servers close to your users · Fly

Fly.io

October 27, 2025 at 5:53 PM

Reposted by Jérôme Gravel-Niquet

rain 🌦️

@sunshowers.io

Why I like and keep working on Rust

Thank you for the kind words and the thoughtful response.
I'm deeply sympathetic to your viewpoint, and some days I certainly feel like Rust is creaking under its own weight. Why does your typical backend web service need all this complexity with borrows and lifetimes and manual memory management?

But allow me to present the other side of the argument. My background is in systems-level developer tools, and Rust has a combination of things that no other programming environment has:

* & and &mut, which enforce a rigorous separation between mutable and immutable state. I think this is the single most important feature of Rust, and the closest analog to this in other environments is purely functional languages like Haskell

* enums with data + exhaustive pattern matching; the latter is something even Haskell lacks

* high-level idiomatic code that performs like low-level code (e.g. iterators): Rust achieves this through an extraordinary combination of monomorphizing and inlining

* working in memory-constrained environments: tracing GC tends to have significant memory overhead, and I've worked in server environments where a big limiting factor was the amount of DRAM being produced globally

* good polymorphism: I think OOP is a suboptimal paradigm that breaks under day-to-day development stress. I've written about it at https://news.ycombinator.com/item?id=42512629

* fast startup times: this is a requirement for command-line tools people use hundreds of times a day—I spent many years working on Mercurial where Python's slow startup time was a very common complaint

* first-class support for using native OS calls directly; many higher-level languages like Java abstract away the details, so things like signal handling are hard to hook into

* first-class Windows support: again, non-negotiable for many developer tools, since the plurality of developers are on Windows

(cont)

* and last but not least, a great dependency ecosystem, which ties into all of the above points: & and &mut mean that some transitive dependency three levels down won't suddenly alter the list you pass in, idiomatic performance means that perf regressions are rare, first-class Windows support means most dependencies just work on Windows, and so on

Is it possible to have an application-level/GCd/managed language that meets most or all of these requirements? Certainly. Does such an application-level language exist today? No, and there's nothing on the horizon either (Haskell has its heart in the right place, but is missing many of the more practical features here).

Rust isn't a great application-level language, but it's the best application-level language. And given how high the barrier tends to be for a new language to reach adoption, I'll probably be retired long before something like that shows up.

And yeah, async really is quite confusing in so many ways, and it's really unfortunate that this situation has seen no improvements in so many years. And yet, through its characteristics combined with the other things listed here, it enables developers to solve real problems that are completely infeasible in any other language.

So I keep trying to make Rust better :)

October 16, 2025 at 11:52 PM

Reposted by Jérôme Gravel-Niquet

Steve Klabnik

@steveklabnik.com

Here's another example of a more thoughtful and nuanced criticism of ai-assisted coding: hojberg.xyz/the-programm...

The Programmer Identity Crisis ❈ Simon Højberg ❈ Principal Frontend Engineer

On AI, Creativity, and Craft

hojberg.xyz

October 8, 2025 at 5:49 PM

Reposted by Jérôme Gravel-Niquet

fjallrs.bsky.social

@fjallrs.bsky.social

If you sponsor NOW (github.com/sponsors/fja...), you can get an exclusive preview of version 3!!

jk I pushed the first pre-release to crates.io - it's unstable though! Breakages guaranteed, and some APIs are missing!

bye

Sponsor @fjall-rs on GitHub Sponsors

Support fjall-rs's open source work

github.com

September 26, 2025 at 7:28 PM

Reposted by Jérôme Gravel-Niquet

Werxzy

@werxzy.itch.io

Due to the amount of people participating in #FallingBlockJam, there's a shortage of blocks, so you're gonna have to make them yourself.

#pico8

September 18, 2025 at 11:17 PM

Reposted by Jérôme Gravel-Niquet

Thomas Ptacek

@sockpuppet.org

JFC this bug. fly.io/blog/parking...

parking_lot: ffffffffffffffff...

Gnarliest Rust proxy bug yet.

fly.io

May 28, 2025 at 10:31 PM

Reposted by Jérôme Gravel-Niquet

Hazel Weakly

@hazelweakly.me

I realized something recently, which is that we're building AI tools completely backwards.

While I was aware that there's some de-skilling happening already, I finally clicked a bunch of pieces together and decided to write this to talk about how we can do *better*

hazelweakly.me/blog/stop-bu...