Design

via Matthias Endler (@mre@mastodon.social): Forgot to share this here: https://corrode.dev/blog/named-arguments-at-home/

Responding to Steve Klabnik’s post on named and optional arguments, Matthias Endler argues Rust already has most of what you’d want — without new language features. Argument structs, builders, and newtypes get you 80% of the ergonomics while keeping the names attached to types rather than to every function’s calling convention.

via Bob 🇨🇦🇲🇽🇺🇦 (@bielsubob@infosec.exchange): Canada built 44 bridges and tunnels across a single stretch of highway so that animals could cross without dying, and collisions with wildlife there have fallen by more than 80%, with grizzly mothers now teaching their cubs to use the crossings like a route the family has always known

Banff National Park’s 44 wildlife crossings — six vegetated overpasses and 38 underpasses, paired with fencing along the Trans-Canada Highway — have cut wildlife-vehicle collisions by more than 80% (96% for elk and deer). What I find most interesting is the multi-decade feedback loop: 250,000+ camera-logged crossings show animals learning the routes and passing that knowledge to their offspring, so the infrastructure gets more effective over time.

Anshu Chimala, who led engineering and design teams at Apple for 12 years, argues that AI models aren’t bad at design — we’re just prompting them into design-by-committee. Because LLMs predict the most likely next token, they default to the blandest possible choices; this piece lays out an end-to-end process for pushing past that toward genuinely distinctive work.

via JA Westenberg (@Daojoan@mastodon.social): Stop trying to build for “the algorithm.”

JA Westenberg lays out five rules for making work that actually lands with people instead of blending into the noise. It’s a short, opinionated read about caring enough to be specific, taking a real position, and accepting that work worth remembering won’t please everyone.

via naz (@nazhamid@mastodon.social): 2.5 years in the making, and Aphera 1.0 is now live and available to download and trial (no cc required), or purchase (50% off for the next two weeks).

Aphera is a native Apple Silicon RAW photo editor for Mac, built around a from-scratch imaging pipeline, film-inspired color science, and a keyboard-driven workflow that stays responsive even on 100MP files. It’s positioned less as a Lightroom clone and more as a fast, project-based tool for photographers who want a signature look applied with one keystroke. Free 14-day trial, requires macOS 15+.

Weather Spark presents historical climate averages for any location on Earth — temperature, precipitation, cloud cover, and daylight — as beautiful year-round charts. Not a forecast tool, but exactly what you want when picking dates for a trip or wondering what a place is actually like in March.

via Hacker News 100 (@hn100@social.lansky.name): How’s Linear so fast? A technical breakdown

Dennis Brotzky reverse-engineers the architectural decisions that make Linear feel instantaneous: a real database (IndexedDB) in the browser, local-first mutations that render synchronously, and a sync engine that pushes deltas over WebSockets in the background. It’s a good tour of the local-first playbook — the core insight being that the fastest network request is the one you never make.

An interactive explainer on the physics behind GPS, covering how satellite signals, timing, and relativity all come together to pinpoint your location. A beautifully crafted piece that makes complex physics accessible and engaging.

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.

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 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.

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).

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.”

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.

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): 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): 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.

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.

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.

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!

via Stefan Judis (@stefan@front-end.social): A clear visual demonstration of why oklch() should replace hsl() for CSS color palettes: when you rotate the hue angle, oklch() maintains consistent perceived lightness while hsl() can shift dramatically. The interactive examples make the difference immediately obvious.

via Esther Schindler: Experience Flying Toasters, After Dark’s most popular Mac screensaver of the 1990s, reinterpreted using modern CSS.

via Zach Leatherman: A few weeks ago I asked y’all what blog posts were most influential to how you build for the web. I had a lot of fun building a little micro-site for these links and it’s now available:

Design concept for an icon to easily identify AI-generated concept.

via Ethan Marcotte: 🦊 Sometimes a thing happens where you can’t spend any more time on the website you spent fifteen literal years on, and maybe that’s okay.

via Rust Weekly: Unsafe: on Rust still being helpful even with a lot of unsafe

via kottke.org: Sweden Sans is the national typeface of Sweden and is available to download (not sure about the usage rights tho).

Tim Bray asked for and found help bringing his home-grown CSS into the modern/mobile era.

via Kevin Stewart:

via Daring Fireball: Hoefler’s Proof for Testing Fonts

via kottke.org: Some notes on the design of the alphabet. "Love the spacing between vowels!"

Interesting and perhaps controversial idea: Lead with the CTA and social media posts.

via Rust Daily: Safety and Soundness in Rust:

I ran across this article on the hot mess that is YAML recently and enjoyed it for many reasons.

Tantek Çelik: 11 years ago today, Ryan Barrett launched Bridgy to copy #socialmedia replies as comments on original blog posts. This meant those of us building #IndieWeb sites could use a service for that functionality, instead of having to write code ourselves, for each proprietary API.