Woah, check this!
I came across this easy mistake to miss in #Rust!
Modern Rust is so tricky!
Luckily the Rust Geesechecker stopped me from pushing this to production and forgetting to value the #Goose.
Here we can see on line 190 I clearly forgot to value the goose, which would have resulted in a catastrophic market segmentation fault!
Luckily the #Rust compiler knows that the true source of value is the Golden Egg factory inside the #goose

Alt...

error[E6005]: use of unvalued goose: `goose` --> src/main.rs:192:24 | 189 | fn internal_mechanism(asi: &mut sb::ASI) { | -- value miscalculation occurs because type `Egg` does not implement the `Lay` trait 190 | let mut _goose = asi.goose_mut(); | ^ goose was not valued here 191 | 192 | let egg = _goose.lay(); | ^^^ egg laid here after move warning: unvalued variable: `goose` --> src/main.rs:190:9 | 190 | let _goose = asi.goose_mut(); | ^^^^^^ help: if this is not intentional, remove the prefixed underscore: `goose`

New release: #rPGP version 0.20.0 🧰🔐

https://github.com/rpgp/rpgp/releases/tag/v0.20.0

#OpenPGP implemented in pure #Rust, permissively licensed

This release changes the default decryption behavior for SEIPDv1 messages to MDC-check first.
While this can be less efficient for large messages, it is a defensive best practice (see https://github.com/rpgp/rpgp/issues/662).

It also includes various bug fixes for stability, and improved build speed.

Finally, the release adds all functionality from draft-wussler-openpgp-forwarding.

I'm very interested in systemic solutions to problems. Blaming an individual when they make a mistake *feels* reasonable. When a significant percentage of people make the same mistake (70%, 2%, it doesn't matter as long as it is measurable, predictable and has a negative impact), then it's *not* a persons fault.
We know how to tackle those kind of problems: we change the environment to minimize the likelihood of mistakes. Traffic and pedestrian safety is an example of a well explored space where we know what works. Bollards, narrower streets, slower speeds, raised pedestrian crossings, providing good alternatives to driving to reduce traffic...
Similar in industrial spaces: clear signaling, segregate heavy machinery from human limbs, clear and practiced process to get out of dodge when things go poorly...
It's always about looking for solutions to eliminate mistakes, and when they can't be eliminated, minimize the blast radius.
This is why I like #Rust: it's a language and tooling that applies the industrial approach of "if two people make this mistake, figure out how to mitigate it".
We can't "individual responsibility" our way out of systemic problems.
I want more software with bollards.

Machine Learning with Rust, Second Edition: Implement data pipelines, classical models, deep learning and NLP using burn, candle, linfa and smartcore by GitforGits | Asian Publishing House is a new release on Leanpub!

Link: https://leanpub.com/rustmachinelearning

#books #ebooks #newreleases #leanpublishing #selfpublishing #machine_learning #deep_learning #neural_networks #large_language_models #ai #rust

Rust From the Ground Up by M Provost is on sale on Leanpub! Its suggested price is $39.99; get it for $24.74 with this coupon: https://leanpub.com/rust-from-the-ground-up/c/LeanPublishingDaily20260618 #computer_programming #rust

Rust for Javascript Developers: A Practical Guide to Systems Programming for the Web Developer by Dwayne Charrington is a new release on Leanpub!

Link: https://leanpub.com/rustforjavascriptdevelopers

#books #ebooks #newreleases #leanpublishing #selfpublishing #software #rust #computer_programming #javascript

Rust for Linux Programming: Build kernel modules, drivers, file systems, networking, and memory using Rust's ownership, traits, and RAII by GitforGits | Asian Publishing House is a new release on Leanpub!

Link: https://leanpub.com/rustlinuxprogramming

#books #ebooks #newreleases #leanpublishing #selfpublishing #rust #algorithm #compiler #systemsengineering #data_structures

Verification complete with a successful result!

My next project will be a #Radicle orchestrator process that can mirror our repos to third-party resource (like our read-only presence on GitHub).

While I find #Rust easy to read, I haven't written much #Rustlang code yet. This will be a good exercise in learning Rust. :-)

The main idea is to implement bunches of features in this orchestrator (the first being the aforementioned repo mirroring support.) The next feature will likely be per-commit emails and issue/patch notifications via #Pushover.

TIL the --locked argument to 'cargo install', necessary to workaround upstream breakage in the time crate causing bob to fail, and looks like lots of others:

https://github.com/time-rs/time/issues/783

Doesn't seem great that a broken publish of an indirect dependency can break so much software, and there was much WTFing while trying to explain why a build that worked yesterday didn't work this morning.

Why isn't --locked the default?

#rust #rustlang #bob