2024

via Matt Weagle (@mweagle@hachyderm.io): “Mmmmmmmm, others. The ones who have always stood a little bit outside the system. Who could never quite adjust themselves to the right configuration to fit into the workings. Who have always felt a bit out of place. Who look at the systems, all of them, and wonder, Is this really the best we can do? “

Annie Mueller on how the systems we build to serve a goal eventually grow into mutant beasts whose only real purpose is their own survival — until the people no longer serve the goal, they serve the system. The sharpest part is her taxonomy of how people react when a system is threatened: those who can’t see the system as a system fight for it as if reality itself were crumbling, while those who recognize it as a structure imposed on reality are the only ones with the power to change it.

Barry Jones makes a thorough case that story points are unreliable by design: low values imply precision, high values imply ranges, and velocity quietly converts them back into time anyway. Instead of arguing about Fibonacci numbers, he argues teams should measure queues — how long work waits — which gives the business the timeline predictability it actually wanted.

via Alexis Jacomy (@jacomyal@vis.social): Just found out about SiteOne Crawler: https://crawler.siteone.io

SiteOne Crawler is a single dependency-free binary that deep-crawls any site and produces an interactive audit report covering SEO, security headers, accessibility, performance, and broken links. It can also mirror a site for offline use, generate sitemaps, or convert pages to clean Markdown / llms.txt for feeding to an LLM. Available as a desktop GUI or a CLI with roughly 200 options, so it slots nicely into a CI/CD quality gate.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Introduction to durable execution with Flawless and Rust

Flawless is a durable execution engine for Rust: workflows that run to completion even when the process is killed mid-flight. Instead of hand-rolling a state machine with resume rules and idempotence guarantees around every external API call, you write plain business logic and let the engine handle the replay. Currently in beta 3.

via Niléane (@nileane@nileane.fr): Attached: 1 image

Unread, long a favorite RSS client on iOS and iPadOS, has finally landed on the Mac with version 4.0 — a fully native AppKit/SwiftUI app that’s fast, customizable, and supports Feedbin and other sync services. Nice to see continued investment in native Mac RSS readers as the open web and fediverse feeds keep growing.

The Choluteca Bridge in Honduras survived Hurricane Mitch intact — but the hurricane moved the river out from under it. Mike Bowler uses this as a memorable parable for long delivery cycles: you can build exactly the right thing perfectly and still miss, because the world changed while you were building. The antidote is shortening the time from idea to in-use: smaller slices, less work in progress, fewer dependencies, and real collaboration.

via Thomas (@wheezle@hachyderm.io): Been writing code in the sans-IO style for a while now and really enjoying it so I wrote up a blog post about it! #rustlang

Firezone’s Thomas Eizinger explains the sans-IO pattern: implementing network protocols as pure state machines that never touch a socket or call Instant::now themselves, leaving all IO and timing to the caller. The payoff is fast, exhaustive, deterministic tests and a way to sidestep the “function colouring” problem — async ends up confined to a thin outer layer instead of infecting the whole stack.

via Natalia Panferova (@natpanferova@mastodon.social): Excited to share that @hishnash and I have just released our new app, Strolly!

Strolly generates fresh looping walking routes near you each day, using on-device pathfinding so your location data never leaves your phone. You can steer it toward areas you like, flag segments to avoid, and get time estimates tuned to walking, jogging, or running — a nice antidote to always taking the same route.

via yosh (is out of office) (@yosh@toot.yosh.is): New blog post: Ergonomic Self-Referential Types for Rust

Yosh Wuyts sketches what it would take to make self-referential types in Rust genuinely ergonomic: 'self lifetimes, in-place construction, an !Move marker in the type system, and safe phased initialization without the option-dance. It’s an early exploration rather than a finished design, but it’s a useful map of how several proposed features could combine to replace the awkwardness of Pin.

Kev Quirk walks through EchoFeed, Robb Knight’s managed service that watches an RSS feed and automatically cross-posts new entries to Mastodon, Bluesky, Micro.blog, GitHub, Discord, or a webhook. It’s free for a single feed and $25/year for more (with a discount for omg.lol members), making it a cheap, set-and-forget alternative to Micro.blog’s cross-posting service.

The New York Times looks at how outdoor magazines like Backpacker and Outside have shed their print editions, and what’s lost when a genre built on long-form storytelling and large-format photography moves entirely online. A reminder that the economics of digital publishing reshape not just distribution but the kind of work that gets made.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Htmd: A turndown.js inspired HTML-to-Markdown converter for Rust

htmd is a Rust crate for converting HTML to Markdown, modeled closely on turndown.js — it offers the same rich set of options and passes turndown’s test suite. Handy if you need reliable HTML-to-Markdown conversion in a Rust pipeline without shelling out to a JavaScript runtime.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Introducing emit: developer-first diagnostics for Rust applications

Ashley Mannix introduces emit, a diagnostics framework for Rust that’s been years in the making. Rather than following OpenTelemetry’s data model, everything is a single primitive — an event, described by a message template — from which logs, trace spans, and metric samples are all built. It still plugs into OTLP collectors, rolling files, or a pretty-printed console when you want them.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Building a dynamically-linked plugin system in Rust

Micah Wylde walks through how Arroyo, a real-time SQL engine, supports user-defined functions in a language that really wants to produce static binaries. He weighs scripting languages, out-of-process RPC, and Wasm before landing on dynamically-linked shared libraries with a C ABI, then digs into the details of designing safe FFI types and interfaces. A great read if you’ve ever wondered how to make a Rust program extensible at runtime.

A Changelog & Friends episode on self-hosted media servers — Plex, Jellyfin, Emby and the rest — and why keeping your own library still beats renting from streaming services. A good listen if you’re thinking about reclaiming your media from the cloud.

Linear is repositioning itself as “the product development system for teams and agents” — issue tracking, planning, and triage built around workflows shared by humans and AI agents. Worth a look if you’re thinking about how coding agents fit into an existing project management practice (and, as always, the design and performance polish of the product itself is exemplary).

via Axel Rauschmayer (@rauschma@fosstodon.org): Monolith lets you download a complete web page as a single HTML file—by inlining images etc.

Monolith is a Rust CLI tool that bundles an entire web page — CSS, images, JavaScript, fonts and all — into a single self-contained HTML file with no external dependencies. A handy way to archive pages that might not survive the next site redesign or link rot purge.

via Jan Lehnardt :couchdb: (@janl@narrativ.es): Well, officially in the market for a Slack replacement now. Hit me. What are you personally happy with in a small business setting, strong macOS/iOS support, user friendly, including nontechnical folks?

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Blazingly Fast Linked Lists

Linked lists are usually an interview trivia question rather than a practical tool, but Dmitry Dygalo shows a case where they genuinely beat Vec: tracking the current location during JSON Schema validation so errors can point at the exact spot in the instance. The post walks through a series of optimizations drawn from real work on the jsonschema crate, measuring the impact of each step.

A short segment near the end of Tim Ferriss’s conversation with Craig Foster (of My Octopus Teacher) about how to approach debates on contentious political issues. The advice — lead with genuine curiosity rather than the intent to win — applies just as well to technical disagreements as political ones.

Industrial Logic frames code quality as a set of seven “virtues” — qualities like clarity, simplicity, and testability — rather than a checklist of rules. It’s a useful vocabulary for code review conversations, giving teams shared language for why a change feels better or worse beyond “I don’t like it.”

via Ars Technica (@arstechnica@mastodon.social): Attached: 1 image

Someone fed the text of the MIT License into Suno’s AI music generator with the prompt “sad girl with piano” and got back a genuinely affecting piano ballad. The highlight: it nails “WARRANTIES OF MERCHANTABILITY” with an Imogen Heap-style glissando, then immediately mangles “FITNESS” into “fistiff.”

via Ethan Sholly (@shollyethan@fosstodon.org): Today I’m launching a project I’ve been working on for several months - a browsable directory of self-hosted software:

Ethan Sholly of the This Week in Self-Hosted newsletter has published his entire database of self-hosted software projects as a browsable directory. You can filter by tags and by the commercial services they replace, and sort by repo stars, recent development activity, or name — with the whole thing refreshed daily from the database he maintains for the newsletter.

Eli Bendersky walks through why the “obvious” approach to parent pointers in a Rust tree fights the borrow checker, then works through the practical alternatives: Rc/Weak pairs, RefCell for interior mutability, and arena allocation with index-based links. A good reference for the moment you hit this wall in your own code.

via Miguel de Icaza ᯅ🍉 (@Migueldeicaza@mastodon.social): Attached: 1 image

A short video gag from Ryan Els capturing the daily relationship between a developer and their IDE — including the autocomplete that insists it knows what you meant to type. The replies are just as relatable: “I just want to use the tab button!”

via Rust Language (@rust@social.rust-lang.org): We got an email from the Serbian Registry of Internet Domain Names (RNIDS), the organisation that is responsible for the .rs top-level domain.

Looks like they are a big fan of Rust. 😊

via Maëlle Salmon (@maelle@mastodon.social): What a cool badge: https://unmaintained.tech/

A badge for projects that are no longer active.

via Martin Fowler (@mfowler@toot.thoughtworks.com): @emilybache@sw-development-is.social has set up a github repository with code samples in several languages for the opening chapter of my Refactoring book. She’s posted a video to her YouTube channel where she introduces this Theatrical Players kata.

Martin Fowler works through the Theatrical Players kata from his Refactoring book, narrating each small, behavior-preserving step as he goes. Watching someone with this much experience talk through the reasoning behind each move — and lean on tests at every step — is far more instructive than reading the finished code.

via Paul Cantrell (@inthehands@hachyderm.io): @voltagex@aus.social Here you go: https://github.com/pcantrell/masto-comment-fetcher

Paul Cantrell shares the Ruby code he uses to pull Mastodon replies in as blog comments on innig.net. It’s not a drop-in library — it leans on context from his own site — but it’s a useful set of recipes if you want to wire fediverse conversations into your own blog.

via Nic Wise (@fastchicken@mastodon.nz): @timbray@cosocial.ca Finally found time to write up how I use Plex + Plexamp. Thanks for asking (the world) and prompting me to actually write the words

A practical guide to self-hosting your music library with Plex and PlexAmp as an alternative to Spotify, Apple Music, and other streaming services. Resonates with anyone who has accumulated a large MP3 collection over the years and wants to maintain control over music they’ve actually paid for.

Roman Kashitsyn lays out a set of goals for designing error types in Rust libraries: prefer specific enums over catch-all types, reserve panics for genuine bugs, lift input validation out of fallible calls, and embed rather than wrap underlying errors. The unifying theme is empathy — design the error type you’d want to handle as a caller.

via Kevin Stewart (@kstewart@hachyderm.io): Observable 2.0 | Observable

Observable 2.0 reframes the notebook company around Observable Framework, an open-source static site generator for building fast, polished data apps from Markdown and JavaScript. Data loaders run at build time, so dashboards ship as plain static files — a refreshingly simple architecture for data visualization on the web.

via Kevin Stewart (@kstewart@hachyderm.io): Why is building a UI in Rust so hard? | Warp

The Warp team explains why Rust’s ownership model — great for systems code — fights against the shared, mutable, deeply-linked object graphs that traditional UI frameworks depend on. Their answer was to go functional: an immediate-mode, state-driven UI architecture that plays to Rust’s strengths instead of against them.

via Federico Viticci :ticciseal: (@viticci@macstories.net): Attached: 1 image

Greg Pierce (of Drafts fame) has released Simple Scan, an iPhone and iPad app that does exactly one thing: scan a document to PDF or image and send it where you want. No cloud accounts, no expense report workflows, no ads — just a couple of options and a big Scan Document button, which is precisely right for those of us who scan a receipt once a month.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): arbtest — powerfully tiny property-based testing

arbtest is a property-based testing library for Rust with a refreshingly tiny API: one function, no macros. It takes an arbitrary::Unstructured random data source, shrinks failures automatically, and prints a seed you can use to deterministically replay any failure — plus it supports time budgeting and works with fuzzers.

via Alexandre Colucci (@timac@mastodon.social): Attached: 1 image

MarkChart is a native Mermaid diagram editor for iPhone, iPad, and Mac, with live preview, syntax highlighting, an interactive visual canvas, templates, and Quick Look support for .mmd files. Handy if you write flowcharts, sequence diagrams, or Gantt charts as text and want polished PDF/PNG/SVG exports without a browser-based tool.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Wrote a blog (and benchmark) different type of builder patterns in rust

A small benchmark repo comparing different ways to implement the builder pattern in Rust — owned self, &mut self, typestate, and friends. Handy data if you’ve ever wondered whether your builder’s ergonomics come at a runtime cost.

The Rust project’s 2023 annual survey results are in, drawing on responses from tens of thousands of Rust users about how (and where) they use the language, what they find hardest, and what they want next. Always a useful snapshot of where the community’s collective attention is heading — and yes, Vim landing near the top of the editor list generated the usual cheering.

An episode of Adam Grant’s ReThinking (via the WorkLife feed) featuring Denise Hamilton on revising the stories we hold dear — the narratives we tell ourselves about our work, our teams, and each other. A good reminder that the beliefs we’re most attached to are often the ones most worth re-examining.

via Simon Willison (@simon@simonwillison.net): And Fly.io announced their object storage alternative to S3! https://fly.io/blog/tigris-public-beta/

Fly.io introduces Tigris, a globally distributed, S3-compatible object storage service that caches objects near where they’re requested instead of pinning them to a single region. Fly’s take is refreshingly honest: they couldn’t figure out how to beat S3 themselves, so they’re pointing at someone who did — at least for the kinds of apps that run on Fly.

via Martijn Faassen has moved (@faassen@fosstodon.org): I’ve just released a major change to the Xot XML tree library in Rust, version 0.21. It breaks a lot of APIs (as I’m the only major user at this point in time, I can still do it), and adds a lot of new functionalities.

Xot is, I claim, by far the most fully featured XML tree manipulation library available for Rust.

via Tim McNamara (@timClicks@mastodon.nz): Attached: 1 image

Tim McNamara points out a handy Rust tip: rustup can generate shell completions for itself and for cargo, so you get tab completion for subcommands and flags in your shell of choice. A small quality-of-life win that’s easy to miss in the rustup docs.

Jon Reid revisits the Single Responsibility Principle and argues that the usual “a class should do one thing” shorthand misses the point — the real test is how many different reasons (and stakeholders) could force a change. A useful reframing for anyone who has watched SOLID discussions devolve into arguments about how small a class should be.

A Siri shortcut that captures highlights from whatever you’re listening to in Overcast, transcribes and summarizes the surrounding audio, and syncs the result to Readwise (and from there to Obsidian, Notion, Roam, etc.) or email. “Hey Siri, highlight” is exactly the interaction I want when a good idea goes by while my hands are busy.

Via https://overcast.fm/+QCTSW_xSc/15:55

via Molly White (@molly0xfff@hachyderm.io): When people say you should “own your own data,” or that the future of the web is “ownership,” what does that mean?

Molly White untangles the many contradictory things people mean when they say “digital ownership” — buying media you can’t keep, controlling your own data, owning your audience — and argues we’d be better served by naming the specific rights we actually want. A clarifying read that cuts through both platform lock-in apologetics and crypto “ownership era” hype.

via daniel roe 🇺🇦 (@daniel@roe.dev): 👋 Announcing a new open-source side project:

👉 Put in your domain name to see your Core Web Vitals / Lighthouse score - and then share it easily on social media.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Rust Won’t Save Us: An Analysis of 2023’s Known Exploited Vulnerabilities

Horizon3’s analysis of the 2023 CISA Known Exploited Vulnerabilities catalog finds that memory-safety bugs account for a relatively small share of what attackers actually exploit; injection flaws, authentication bypasses, and logic errors dominate. A useful reality check for those of us who reach for Rust as a security panacea — memory safety closes one door, but plenty of others remain wide open.

via Brian Dorsey (@briandorsey@hachyderm.io): #rust #rustlang

binrw is a Rust crate that uses declarative attributes on ordinary structs and enums to generate binary parsers and writers, with support for endianness, conditional fields, and custom encodings. If you’ve ever hand-rolled byte-offset math for a file format or network protocol, this is a much safer and more readable way to do it.

via codepilot (@codepilot@chaos.social): It seems that “The four horsemen of bad #Rust code” by @mre@mastodon.social from #fosdem2024 is now available https://video.fosdem.org/2024/h1308/fosdem-2024-2434-the-four-horsemen-of-bad-rust-code.av1.webm

A FOSDEM 2024 talk on “The Four Horsemen of Bad Rust Code” — the recurring anti-patterns that show up when teams write Rust that compiles but fights the language instead of working with it. A good watch if you’ve ever wondered why your Rust code feels harder to maintain than it should.

via Shafik Yaghmour (@shafik@hachyderm.io): Attached: 1 image

A five-question C quiz where the correct answer to every question is “I don’t know” — structure padding, integer promotion, implementation-defined char signedness, and unsequenced side effects all conspire to make seemingly obvious code undefined. A good humbling reminder that knowing C’s syntax is not the same as knowing what the standard actually guarantees.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Achieving Safe, Aliasable Mutability with Unboxed Types

Jake Fecher explains how the Ante language aims to allow aliasable mutability without giving up memory or thread safety, using unboxed types to sidestep Rust’s “Aliasability XOR Mutability” rule. A thoughtful look at one of the most common sources of friction in Rust’s borrow checker and what a different set of tradeoffs might look like.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): jj init: What if we actually could replace Git?

Chris Krycho makes a thorough, well-argued case for Jujutsu, the new Git-compatible version control system out of Google. His critique of Git’s incoherent mental model is worth the read on its own, but the real payoff is seeing how jj rethinks the working copy, revisions, and conflicts into something you can actually reason about.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Why Rust in Production?

Matthias Endler talks through several arguments for and against using Rust in production based on his experience consulting with many firms large and small.

Ryan Trimble shares a handful of VS Code plugins he’s used so long he forgot they weren’t built-in — Markdown All in One (paste a URL over selected text to make a Markdown link), Better Comments for highlighted TODO/alert annotations, and Peacock for color-coding windows per workspace. Handy if you do a lot of Markdown authoring or juggle many projects at once.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): My Best and Worst Deadlock in Rust

Michael Snoyman walks through building a subtle Rust deadlock step by step, using an RwLock-guarded struct and a seemingly innocent read-then-write pattern. It’s the “worst” deadlock because it hides in plain sight, and the “best” because the tooling pointed straight at the culprit. Worth reading even if you think you know Rust’s concurrency rules.

via Andrew Lokenauth (@FluentInFinance@mastodon.social): The wealthy avoid taxes using the “Buy-Borrow-Die” strategy:

Andrew Lokenauth walks through the “Buy-Borrow-Die” strategy: the wealthy hold appreciating assets, borrow against them at low rates instead of selling (avoiding capital gains), and pass the assets on with a stepped-up basis so the gains are never taxed. A concise explanation of a tax loophole that’s hiding in plain sight.

A browser-based editor for building realistic US highway guide signs — panels, shields, control cities, arrows, and all — with the ability to save the result as an image. Ooh, this could be dangerous!

Luca Palmieri fills a real gap in the Rust adoption literature: not how to convince your org to try Rust, but what to do once you’ve decided. His advice to not hire Rust specialists for your first project — and instead assess and upskill the team you already have — rings true, as does the warning about stranding a team of frustrated Rust experts if the bet doesn’t pan out.

Dan Moren drops Feedly and moves his RSS subscriptions into Reeder’s own iCloud-synced feed list, cutting out the sync service entirely. The bigger point: RSS and OPML remain one of the few places where moving your data between apps and services takes about a minute — a portability standard the rest of the web could learn from.

Prossimo’s benchmarking work on Rustls shows the Rust TLS implementation already beating OpenSSL 3.2 in several scenarios, with automated per-PR performance feedback to catch regressions. A nice demonstration that memory safety doesn’t have to come at the cost of performance — historically the main argument for staying with C.

via Axel Rauschmayer (@rauschma@fosstodon.org): Two projects that sync in-browser SQLite databases with servers:

SQLSync is a collaborative, offline-first wrapper around SQLite that syncs web application state between users, devices, and the edge. Written in Rust and compiled to WASM, it brings reactive query subscriptions and automatic conflict resolution to local-first apps without requiring you to hand-roll a sync layer.

via Jan (@janpio@hachyderm.io): @scouten@ericscouten.social we have been trying https://codspeed.io/ for that use case. Works decently. Check github/prisma/prisma-engines PRs for examples.

CodSpeed runs benchmarks as part of CI and flags performance regressions directly in the pull request, using instrumentation rather than wall-clock timing so results aren’t drowned out by noisy shared runners. It supports Rust, Python, Node, and Go, and several open source projects use it to keep an eye on performance drift over time.

Terry White chronicles replacing his aging whole-house Bose SoundTouch setup with Sonos, after years of watching a discontinued product line slowly rot — half-baked AirPlay 2 support, speakers dropping offline, and no hope of fixes. A good reminder that with connected hardware, you’re buying the vendor’s software commitment as much as the speakers themselves.