Dev

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 Barney Dellar (he/him) (@BarneyDellar@mastodon.scot): “Do you still read the code?” This is a very interesting article on the state of software development, and what it means to write software. https://zanlib.dev/blog/do-you-still-read-the-code/

A familiar state of affairs: teams now share codebases without agreeing on whether anyone is still expected to read the code. Zanlib draws a useful distinction between “accelerators,” who use AI to translate their own understanding into code and stay responsible for it, and “vibe coders,“ who delegate implementation and its revision entirely. The costs of either choice won’t be visible until the code has to survive changes in requirements, tooling, and people.

Crit is a local, browser-based review surface for AI agent output: point at line 47 of the diff, type “this drops the refresh token,” and the agent picks up the comment and fixes it. Beyond code diffs it also handles plans and docs, running dev servers, and static HTML artifacts — each of which terminal scrollback handles badly. Self-hostable and works with git, jj, and sapling.

via Assaf 🌴 (@assaf@mas.to): Throughout a single piece of writing you’ll face two different questions: What context does the reader already have? and, crucially, What context does the reader need? The gap between those two answers defines the piece.

Addy Osmani has distilled eighteen rules for clear writing into an open-source Agent Skill that can interview you, rewrite a draft, or simply critique one without touching your file. There’s also a private browser-based editor that flags AI writing tells, readability problems, and gaps in substance. The underlying essay stands on its own as good writing advice, whether or not you ever install the skill.

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 RustTrending: A feature rich, native desktop, YouTube Music client. Tauri + Rust + SvelteKit, ad-free playback through libmpv, Last.fm scrobbling and Discord Rich Presence, no Electron.

CodeScene combines static analysis with behavioral analysis of your version-control history to surface the hot spots where technical debt actually costs you — and it scores maintainability with a “CodeHealth” metric that’s validated against defect and delivery data.

via Assaf 🌴 (@assaf@mas.to): Attached: 1 image

omp is a coding agent that runs with an IDE wired directly into it, so the model can use real editor and language-server context instead of guessing from raw text. An interesting take on where agentic coding tools are heading: less chat window bolted onto a terminal, more agent living inside the dev environment.

via Assaf 🌴 (@assaf@mas.to): Ephemeral is fine. We used the sleep app for about four months. Our son sleeps through the night now, so we retired it. If the app had taken me months to build, that might sting. Because it took a week, I’m just glad it worked when we needed it.

Adam Waxman picks up Robin Sloan’s “an app can be a home-cooked meal” thread and shows what it looks like in 2026: a sleep tracker built from his consultant’s PDF, a fitness app that sizes his morning smoothie to that day’s run, a marathon plan derived from his actual race data. With AI assistance, software written for an audience of one (or four) is now a weekend project instead of a career.

This rings very true for me.

Peter Schmidt talks with Graham Lee about whether spec-driven development is a genuine successor to agile or just waterfall wearing an AI costume. A good counterweight to the “agile is dead” hype cycle, with an extensive set of links to the broader debate in the show notes.

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.

via Astra Underscore (@astra_underscore@wetdry.world): I feel like some of you Rust freaks might be into this:

Creusot is a tool that helps you formally prove your Rust code is correct. It uses deductive verification to let you write specifications as annotations in your Rust code and then verify them automatically, bringing the power of formal methods to everyday Rust development.

A nice description of how ASN.1 encoding works.

Lorin Hochstein stages a short play in which an engineering manager discovers the “carefulness knob” — the dial a team implicitly turns when deciding how much testing and process rigor a change deserves. The punchline is that cranking it to maximum doesn’t eliminate incidents, it just pushes delivery dates out exponentially, and teams are far worse at estimating risk than anyone would like to admit.

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.

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

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.

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

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

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.

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

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.

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.

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.

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.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Announcing mdbook-pandoc: a mdBook backend powered by Pandoc. Render mdbooks to PDFs and much more!

An mdbook backend that uses Pandoc to generate output formats like PDF, EPUB, and more from mdbook projects. This is a useful tool for anyone writing documentation or books in Markdown with mdbook who needs high-quality typeset output beyond HTML.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Announcing Continuous Memory Profiling for Rust

Polar Signals, in collaboration with Materialize, has released rust-jemalloc-pprof, a library that exports jemalloc’s heap profiling capabilities in pprof format. This makes it much easier to debug memory leaks and understand heap usage in Rust applications, either as one-off investigations or as continuous profiling over time.

via Mikah Sargent (@mikahsargent@mastodon.social): 🤯 Blown away by this video from @film_girl showing the racks that house the tech for GitHub’s new M1 macOS Runners. Was not expecting to see the Minis deconstructed!

GitHub announces new custom M1 macOS runners for GitHub Actions, discussed in a sneak peek video with Christina Warren. This is a welcome addition for teams that need ARM-native macOS CI/CD pipelines.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Common mistakes with Rust Async

A practical guide to common pitfalls in async Rust, starting with the often-overlooked issue of task cancellation. The Qovery team shares hard-won lessons about how async tasks can be stopped at any await point, leading to subtle bugs like counters that never decrement. A valuable read for anyone working with Tokio and async Rust in production.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Introducing FireDBG - A Time Travel Visual Debugger

FireDBG is a time travel visual debugger for Rust that captures function call trees, arguments, and return values, then lets you navigate backward and forward through program execution. Instead of littering code with println! statements, it visualizes the entire control flow as an interactive call tree. A fascinating approach to making Rust debugging more intuitive.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Linus on Rust in the Linux kernel (December 2023)

Linus Torvalds sits down with Dirk Hohndel for a wide-ranging keynote conversation at the Open Source Summit. Always interesting to hear Linus’s unfiltered thoughts on the state of Linux, development practices, and the open-source ecosystem.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): On inheritance and why it’s good Rust doesn’t have it

Jimmy Hartzell continues his series on why Rust is beyond object-oriented programming, tackling inheritance — the most problematic of OOP’s three pillars. He makes a compelling case that inheritance’s appeal is largely based on misleading textbook examples (shapes, animals) that have little to do with real-world programming, and explains why Rust deliberately omits it in favor of better composition patterns.

via Mara Bos (@Mara@hachyderm.io): 🦀 New #rustlang blog post! “Behind the Scenes of Rust String Formatting: format_args!()”

A deep dive into how Rust’s format_args!() macro and fmt::Arguments type work behind the scenes. Mara Bos explores the current implementation, its trade-offs in structure size, code size, and runtime overhead, and brainstorms potential future improvements. A fascinating look at one of Rust’s most ubiquitous but underappreciated building blocks.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Common Rust Lifetime Misconceptions (2020)

An excellent and thorough walkthrough of common misconceptions about Rust lifetimes. Covers key misunderstandings such as confusing lifetimes with scopes, thinking lifetimes can grow or shrink at runtime, and misunderstanding the relationship between T, &T, and &mut T with respect to lifetime bounds. A must-read for anyone looking to deepen their understanding of Rust’s ownership model.

via Matthias Endler (@mre@mastodon.social): If you don’t run parallel rustc yet, give it a shot. Nice perf boost on modern hardware.

The Rust compiler is gaining parallel front-end compilation support, which should help improve compile times for large Rust projects. This has been a long-awaited improvement in the Rust ecosystem.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): mem_dbg is a crate to recursively compute the memory usage of a data structure or print its layout

A Rust crate for measuring and displaying the memory usage of data structures, providing both the actual heap memory consumption and the capacity-based memory usage. Useful for profiling and optimizing memory in Rust applications.

via nrc (@nrc@hachyderm.io): Blog post: A response to ‘A decade of developing a programming language’. https://www.ncameron.org/blog/a-response-to-a-decade-of-developing-a-programming-language/

Nick Cameron, a long-time Rust contributor, responds to a blog post about a decade of programming language design. He shares thoughtful opinions on gradual typing, simplicity vs. expressivity in type systems, error handling design, and the tension between language complexity and usability.

via Rust Weekly 🦀 (@rust_discussions@mastodon.social): Rust global variables, two years on

A thorough update on the state of global variables in Rust. With Mutex::new() now being const and OnceLock in the standard library, many common patterns that previously required external crates like once_cell or lazy_static now work out of the box. A great reference for anyone working with Rust globals.

via C & C++ Weekly (@c_discussions@mastodon.social): Idiomatic Rust (for C++ Devs): Constructors and Conversions

A thorough guide mapping C++ constructor patterns to idiomatic Rust equivalents. Covers initialization, default construction, conversions, copy/move semantics, and the From/Into traits, making it useful for anyone transitioning to Rust from C++ or similar languages.

Will Larson on Irrational Exuberance: Navigators

via mako: Anyone set up @forgejo with Working Copy ( @palmin )? I’m getting this error, not sure what to try next; tried both user/password and app token (which has this enabled).. perhaps it’s because it’s behind a reverse proxy?

via Rust Trending: greyblake / nutype: Rust newtype with guarantees 🇺🇦 🦀 ★972

Alex Kladov on matklad: Push Ifs Up And Fors Down

via Rust Weekly 🦀: Nix users, you can fearlessly start using Rust scripts already

via Chris Biscardi: Really enjoyed this post by @benwis on using cranelift and mold/sold to improve Leptos compile times. Includes explanations and benchmarks.

via Valentine Briese :transuwu:: Little bit of a trick I discovered for documenting fields which are on multiple structures:

via Matthias Endler: I wrote an article on “Rust in Production.”

via shuttle: RUST WEB FRAMEWORK COMPARISON 🚨

via Matt Weagle: TIL “Git notes are powerful tools. And they could solve so many problems — if only they were better known and easier to use.”

via Rust Weekly 🦀: Rust async vs C# async vs C++ async

via Rust Weekly 🦀: Microsoft is doubling down on Rust

via Johanna Rothman: Want Both Efficiency and Effectiveness? Lower WIP and Right-Size Work

via Matt Weagle: “I’m not asking to be trusted. I’m not asking to be let off the hook. I’m asking to work toward shared goals everybody cares about & to be left all the tools in my belt to reach those goals.”

via Nicolas Fränkel 🇺🇦: We invested 10% to pay back #techdebt; Here’s what happened

via shuttle: LINK CHECKING WITH RUST 🌟

via Kevin Stewart: Seriously, Write Your API Spec First | Ready, Set, Cloud!

via Kevin Stewart: Conway’s Law and Kubernetes - by drmorr

via Kevin Stewart: How to communicate like a GitHub engineer: our principles, practices, and tools - The GitHub Blog

via yosh: From the Windows blog, about the increasing role @rust is playing in securing Microsoft Surface devices:

via Rust Weekly 🦀: Was Rust Worth It?

via Mo :ferris: :tux:: Faster Rust Serialization 🚀

via Matthias Endler: A quick article on how I deploy Rust apps:

Heather Buchel: It’s 2023, here is why your web design sucks.

via Rust Weekly 🦀: Learning Rust, a Python developer’s perspective

via Brian Sletten: I’m excited to see more and more people get the potential of #WebAssembly. Its fingers are getting into everything, but we’ve only just begun to benefit from what it will allow.

via Kevin Stewart: Beyond Staff Engineer - Alex Ewerlöf Notes

via Jack Rusher: “I will try to convince you that ridiculing JavaScript for this is less insightful than it first appears and that Swift’s approach to string length isn’t unambiguously the best one. Python 3’s approach is unambiguously the worst one, though.”

via heckj: Introducing Automerge for Swift - A CRDT library for Swift that enables multi-user interactive collaboration and seamless sync with offline editing.

via Nicolas Fränkel 🇺🇦: #Rust: compile-time checks in generic functions work, and you can use them in your code

via scy: #Protomaps, a way to serve vector #maps of the entire world using a single static file and HTTP range requests.

via Rust Weekly 🦀: cargo-dist pre-release looking for feedback!

via mcc: A couple people have suggested “interdiff” which looks interesting.

via blinry: Are you curious how Git works under the hood?

via Martijn Faassen: This is a cool post about performance optimization:

via Rust Weekly: A fresh look on incremental zero copy serialization

via Jonathan ‘theJPster’ Pallant: I went in ready to be angry based on the headline, but it’s actually a very agreeable piece.

via fasterthanlime 🌌: Holy fuck, migrating from the rust/cache action to the sccache action made macOS CI times (for a typical PR) fall from 9 minutes to 1 minute

via Dave Copeland :ruby:: One thing I have learned over many years is that you must understand whatever an abstraction is abstracting in order to both evaluate it and wield it effectively. I call this the Katz Conjecture after Yehuda Katz mentioning this in a conference talk:

via Kevin Stewart: Postgres: the next generation. Investing in the next generation of committers. — James Governor’s Monkchips

Yay … GitHub makes hosted M1-based runners available!

via Florian Gilcher: ✅: implemented thanks.rust-lang.org in real life.

Holochain | Distributed app framework with P2P networking

via Rust Daily: How we reduced the memory usage of our Rust extension by 4x

via Rust Weekly: Announcing Zngur: A C++/Rust interop tool

via yosh: I was pinged about fallible drop on the forums, so I wrote a few notes about the design space over there:

Search engine for KERI topics

Cackle is a code ACL checker and is an additional tool to help make supply-chain attacks harder.

via Benjamin Fry: “… we’ve still found Rust to be a significant improvement over C (or C++), both in terms of safety and productivity, in all the bare-metal use cases where we’ve tried it so far.”

via Martijn: This nice little article on dependency injection in #rustlang is a good reminder that blog posts don’t need to be long or complicated to be valuable!

via James Gayfer: After almost a year hiatus, I’ve revived my blog 🎉

via Fabio Valentini: I just wrapped up feature development for rust2rpm v25 (the tool we use in crates and applications). I’ve been dogfooding the latest code for a few days now, and some of the changes make package maintenance much nicer — further reducing the need for manual changes.

via Kevin Stewart: We rebuilt Cloudflare’s developer documentation - here’s what we learned

via Boris Mann: @thisismissem the Heroku successor is something I’ve been chasing for years. Does FlyIO or Railway come close?

via Rust Weekly: Announcing Divan: Fast and Simple Benchmarking for Rust

Via Rust tips: If you want your #Rustlang code to be fast and compact, avoid code that could panic.

via Adam Chalmers: My impressions from Rustconf 2023.

via Rust Weekly: ε-serde is an ε-copy (i.e., almost zero-copy) serialization/deserialization framework

via Boris Mann: Just got off an awesome call with Taz, founder of Guild support.

via Rust Weekly: A Rust Dockerfile boilerplate for quickly building size optimized images

via yosh: “Empathy in Open Source” by Niko Matsakis — I read it earlier today, and imo it’s really good!

via rem: New blog post: “No more 404s” and how I achieved that.

via notgull: New blogpost about Rust!

via Rust Weekly: I wrote a tool to print colorized Rust backtraces.

via Preslav Rachev: Something I point out in every code review I do:

via Rust Weekly: Let’s Build a FIPS-Validated Rust Crypto Library

via Rust Weekly: allocation-counter: Count and test the number of allocations, now with more utility methods

A humorous guide to choosing a programming language …

via Joanna Denni: There are so many really great resources I’ve come across for engineering management, it’s hard to narrow them down!

via Kent Bull: The Trust over IP (ToIP) Foundation is now hosting the KERI protocol specifications.

via Jakub Zalas: “Which Kinds of Tests Should I Write?” I like how nonconfrontational this post is. It’s so hard to give advice this way.

via Kevin Stewart: Death by a thousand microservices

The software industry is learning once again that complexity kills.

Interesting read on what one learns from auditing other company’s code for several years.

via Rust Weekly: A tutorial for accessing C/C++ functions within a shared library (.dll/.so/.dylib) from Rust

via Liam Bigelow: Pagefind 1.0 is here! ✨

via Matt Weagle: “To change the culture, you must change the system. To change the system, you must change what you reward.”

via Matt Weagle: “But incidents can happen as a result of normal work, when everyone whose actions contributed to the incident was actually exercising reasonable judgment at the time they committed those actions.”

via Leonardo Giovanni Scur: @scouten @staltz Not a “diff,” you have to install things its way, but that is the goal of #nix the package manager, which works on both Linux and Mac.

via Johan Wärlander 🦀: @scouten @staltz I guess something like Ansible can take you at least part of the way there?

via Rust Weekly: Silt-Lua, another pure rust Lua interpreter and runtime

via Rust Weekly: set_field: Set fields on structs by string

via Alice I. Cecile: I wrote up the #opensource triage-by-controversy + community code review practices that we use for @bevy.

via Danny Lin: More people need to know about the “tabular numbers” feature that modern fonts have. Use it to make numbers to line up with a UI font (or anything not monospace).

via Kevin Stewart: Using Zig in our incremental Turborepo migration from Go to Rust — Vercel

via yosh: Gah, Sabrina Jewson’s post on Async Drop really was ahead of all of us, and we’re all still just playing catch-up.

via Rust Weekly: Becoming a [Rust] contractor

via Rust Weekly: My Node.js is a bit Rusty: a x25 perf boost by rewriting a Node.js module into Rust with napi.rs

via Dave Rahardja: Ah yes, this is a great way to turn “Can I see your driver’s license?” into “Can you hand me your unlocked phone so I can rifle through it?” at a traffic stop.

via Rust Weekly: Inside Rust Blog: crates.io Postmortem: User Uploaded Malware

via Rust Weekly: 5 Strong Opinions On Everyday Rust

GitHub: “Rust continues to top the charts as the most admired and desired language by developers, and in this post, we dive a little deeper into how (and why) Rust is stealing the hearts of developers around the world.”

via Kevin Stewart: Build a Cross-Platform CLI with Deno in 5 minutes

via Kevin Stewart: More Effective Remote Working | Mike McQuaid

via Kevin Stewart: Tracking Application-Level Consistency with LiteFS · The Fly Blog

via Rust Weekly: Change in Guidance on Committing Lockfiles | Rust Blog

Arash Sal Moslehian: “We take a peek at the inner workings of Tokio, an asynchronous runtime for Rust that provides scheduling, networking, and many other primitive operations for managing asynchronous tasks.”

via Rust Weekly: Stateful Property Testing in Rust

“Rust has great support for type-driven design, which can guide you towards robust and idiomatic code to enforce invariants at compile-time. Always be on the lookout for ways to let the type-system guide you towards stronger abstractions.”

via Bruno Baketarić: “There’s a commonly held myth that a lack of a time-bound delivery commitment, such as a sprint demonstration, will lead to a lack of focus, laziness, and increasingly long delivery times. There is, in fact, no such evidence from more than a decade of training and coaching for a living and wish to dissuade adoption of Kanban or customers from switching.” (David J. Anderson, 2023 in ‘Discovering Kanban’, p. 108)

via Kevin Stewart: </> htmx ~ Hypermedia On Whatever you’d Like

via Jon Reid: @woolie I see very few teams functioning as teams. It might be easier if my views came out in a coherent article rather than tooted in pieces, so check this out if you’re interested. (No obligation to read! I’m also happy to continue tooting.)

via Rust Weekly: Why Rust’s memory safety, performance, and concise syntax were a perfect fit for us

via Nicholas Nethercote: New blog post: “The top-level Rust compiler numbers are 7% walltime reductions and 10% peak memory reductions over the past five months, but read the whole post for the full details.”

via a co-worker: proptest: Hypothesis-like-property-based testing and shrinking.

via Rust Weekly: Picking the right Rust web framework in 2023

via kottke.org: Career advice: keep a current “brag document” that lists what you’ve accomplished with your work. As a one-person company, I often get too caught up in how much I’m not getting done, so this might be a worthwhile exercise for me.

via Rust Weekly: Way too many strings in Rust? You may just need one more, meet hipstr

via Rust Weekly: I’m 15 years old and I wrote a QR code generator in Rust as my first project

via Dragan Stepanović: If developers in your team have to repeat their asks or even worse beg 🙏 for reviewing their PRs (or any other help they need), your problem is not people not prioritizing other people’s work, “lack of professionalism” or lack of “team player spirit.”

via Kevin Stewart: The farther you go up the ladder, the less it’s about your technical skills — Jim Grey

via Kevin Stewart: The Agile Manager: Resistance

via Chromium Developers: Four new CSS features for smooth entry and exit animations

via Rust Weekly: monch: Inspired by nom, but specifically for strings

via Chris Biscardi: I spent the last 6 months rewriting all of my infrastructure and tooling in #rustlang

via Rust Weekly: Inclusion of Rust ring crate now brings cryptographic operations and TLS clients to WASIX

via Kevin Stewart: How engineering teams handle unplanned work | by Anna Debenham | boldstart ventures | Aug, 2023 | Medium

via Kevin Stewart: Logan Keenan - Client-Side Server with Rust: A New Approach to UI Development

via Rust Weekly: Announcing August! An Emmet-like language that produces JSON, TOML, or YAML, written in Rust

via Rust Weekly: The Case for Rust on the Web

via Rust Trending: martinvonz / jj: A Git-compatible DVCS that is both simple and powerful ★3590

Kaliya Young on Medium: Wallet Wars or Collaborative Wallet Ecosystems?

John Arundel on Bitfield Consulting: Rust vs Go in 2023

via Rust Weekly: Client-Side Server with Rust: A New Approach to UI Development

via Rust Weekly: Learning Async Rust With Entirely Too Many Web Servers

via Rust Weekly: Making illegal states unrepresentable

via Jer 🚵🏼: For mac devs or just occasional command line users, this is a great collection of Terminal tips from @chockenberry.

via internet_seer: I’ve seen mention of #git lately and I always want to recommend @b0rk’s wizardzines (but want to not do replyguy-ing with a special interest hyperfixation).

via Python Weekly: Understanding how Rust Python FFI works with cool info-graphics

How to dis somebody’s programming language idea …

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

via Bramus: Is that a new demo over at scroll-driven-animations.style?

via Thomas Steiner :chrome:: 📢 The Origin Private File System (OPFS) is a cross-browser solution for your performance-critical, file-based storage needs on the Web! @chrisdavidmills has documented everything you need to know about the API over on MDN.

💡 This is what powers Photoshop (https://developer.chrome.com/blog/how-photoshop-solved-working-with-files-larger-than-can-fit-into-memory/) and SQLite Wasm (https://developer.chrome.com/blog/sqlite-wasm-in-the-browser-backed-by-the-origin-private-file-system/).

via Rust Weekly: SpacetimeDB: A new database written in Rust that replaces your server entirely

via Kevin Stewart: Things you forgot (or never knew) because of React

via Erlang & Elixir Weekly: Interfacing Elixir with Rust to Improve Performance: Discord’s Story

via Rust Trending: kawasin73 / prsqlite: Pure Rust implementation of SQLite ★42

via HEAPWOLF: @J12t @jamesmarshall @scouten you may also be interinterested in …

via Rust Trending: GyulyVGC / sniffnet: Application to comfortably monitor your Internet traffic 🕵️‍♂️ ★10303

via Rust Trending: supabase / postgres_lsp: A Language Server for Postgres ★1626

via Rust Weekly: Just wrote my first ever blog post on making fake pixel art with Rust and Blender. Feedback appreciated!

via Kevin Stewart: How Managers Can Make Time for Their Own Development

via Kevin Stewart: There’s more to life than OKRs: using EOS and W Planning for effective goal-setting in empowered teams

via Rust Trending: dandavison / delta: A syntax-highlighting pager for git, diff, and grep output ★18097

via Rust Weekly: CachewDB - An in-memory, key value database implemented in Rust

via Matt Weagle: Share your adaptive capacity across the team

via Rust Trending: quickwit-oss / tantivy: Tantivy is a full-text search engine library inspired by Apache Lucene and written in Rust ★8527

via Rust Weekly: Optimizing CI/CD pipelines in your Rust projects

via Rust Trending: sharkdp / bat: A cat(1) clone with wings. ★42279

Irrational Exuberance: Manage your priorities and energy

via Rust Weekly: How to improve Rust compiler’s CI in 2023

via Emily Nakashima: I wrote about why I hate the term “tech debt” and why using more specific terminology often helps us have better conversations about tackling non-product-roadmap work.

via Kevin Stewart: If agile isn’t dead, why is it still not working?

via Causal Islands: Explore community mesh networks, governance on the P2P web, and more in @mauve’s talk.

via Mike Bowler: We’ve announced another public class of Applying Metrics for Predictability over the weekend of October 14/15.

via The Changelog podcast: From Docker to Dagger

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

via Predrag Gruevski: Cargo adopts cargo-semver-checks to ensure semver compliance of its own crates 🔥🔥🔥 @weihanglo once again pushing #rustlang forward, go team! 🦀

via Rust Weekly: An Open Source Project to Create Dashboards 10x Faster in Rust

via Matt Weagle: “By the end, you’ll be prepared to operate effectively within an existing planning process, balance functional and cross-functional demands, and diagnose how your current planning process may be holding Engineering and your company back.”

via Rust Trending: pola-rs / polars: Fast multi-threaded, hybrid-out-of-core query engine focussing on DataFrame front-ends ★18955

via Rust Trending: starship: ☄🌌️ The minimal, blazing-fast, and infinitely customizable prompt for any shell! ★35371

via julia ferraioli :cc_by:: July’s piece dropped late last night — and it’s about undervalued work. Specifically what @whereistanya calls “glue work”.

via Rust Weekly: Blog Post: Can You Trust a Compiler to Optimize Your Code?

I’m a big fan of the Changelog podcast. This snippet was a tight reminder about staying on track when starting a new venture:

via Rust Weekly: High-throughput stream processing in Rust

via Ars Technica: A jargon-free explanation of how AI large language models work

via Francis Gulotta: This @tailscale article on Nat Traversal has been open in my tabs for months. I’ve finally made it to the end and my goodness it’s a good read! The internet is wild, and frankly I think this blog post needs to be an open source library. It’s a powerful understanding that I’ve only seen parts of in #p2p libraries. But I got to be honest, I might not have understood it before even if I saw it.

via Matt Weagle: Excellent conversation

via Rust Weekly: [Code review request] Rhythm: a thread-safe rate limiter in Rust with no dependencies

via Rust Weekly: Is using multi-line /* */ comments a bad practice?

Via Rust Trending: slint-ui / slint: Slint is a declarative GUI toolkit to build native user interfaces for applications that are written in Rust, C++, or JavaScript. ★9105

Via Rust Trending: orf / gping: Ping, but with a graph ★8826

via Rust Weekly: Optimizing Rust programs with PGO and BOLT using cargo-pgo

via yosh: yes… Yes!

via Elijah Manor: 📁 My dotfiles were spotlighted in a recent newsletter

via Rust Weekly: We chatted with the maintainer of Iced - a cross-platform GUI library for Rust. Thoughts?

via Rust Trending: powdr-labs / powdr: A modular stack for zkVMs, with a focus on productivity, security and performance. ★151

via Rust Trending: IgnisDa / ryot: Roll your own tracker! ★452

via Rust tips: Another list of #rustlang tips

via Jon Reid: I teach using mob programming. But the pandemic forced us all to be remote. Here’s what I tried, how it worked, and what I changed going forward.

via Rust Trending: PRQL / prql: PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement ★7931

via 1Password: Developers: Do you use 1Password to manage your SSH keys and push/pull sign git commits? You now have more control over the behavior of your SSH agent.

via Rust Trending: econaxis / time2reach: Public-transit travel time map ★112

via Rust Weekly: I’ve spent time to actually understand Pin and Unpin, so you don’t have to:

via Rust Weekly: Learn Unsafe Rust from My Mistakes

via Martin Fowler: I’ve written a brief summary of Team Topologies, the model created by @matthewskelton and Manuel Pais at @TeamTopologies. Many of my colleagues are finding this to be a useful tool to think about how best or organize software development teams.

via Addy Osmani: The “Software Engineering at Google” book is now free to read online: Great insights on improving code quality & scaling engineering teams.

via Rust Weekly: Rust fact vs. fiction: 5 Insights from Google's Rust journey in 2022

via Rust Trending: o2sh / onefetch: Command-line Git information tool ★7980

via Rust Trending: WebAssembly / WASI: WebAssembly System Interface ★3877

via Rust Trending: TheAlgorithms / Rust: All Algorithms implemented in Rust ★16654

via Rust Trending: Byron / gitoxide: An idiomatic, lean, fast & safe pure Rust implementation of Git ★6554

via Rust Trending: DioxusLabs / dioxus: Fullstack GUI library for desktop, web, mobile, and more. ★10283

via Rust Weekly: SvelteKit and Tauri: Blazing-Fast Desktop Applications

via Kevin Stewart: What I Learned Building a CLI App in Rust - Stratus3D

Sam Ruby on Fly.io Blog: Multiple Logs for Resiliency

via Rust Weekly: Simple Rust Function Macros - Sometimes, repeating yourself is not that bad, as long as macros do it for you

via Rust Weekly: Talloc, a better no_std allocator

via Golang Weekly: How Turborepo is porting from Go to Rust

via Causal Islands: This week we launched the Causal Islands Podcast🏝️ 🎙️ to continue the conversation on distributed systems, AI, computing, local-first software, and more with special guests.

via Rust Weekly: Leptos vs Dioxus vs Sycamore (vs Svelte?): Part 1 — Syntax comparison

via Rust Trending: iggy-rs / iggy: Iggy is the persistent message streaming platform written in Rust, supporting QUIC, TCP and HTTP transport protocols, capable of processing millions of messages per second. ★189

via Rust Weekly: Rust doesn’t have “flattening” (i.e. inline-into) like C/C++. Do you miss it?

Riley Hughes, CEO of Trinsic, interviews Ankur Patel, Head of Product at Entra Verified ID at Microsoft.

via Rust Weekly: Total functions, panic-freedom, and guaranteed termination in the context of Rust

via Rust Trending: cube-js / cube: 📊 Cube — The Semantic Layer for Building Data Applications ★15832

via Rust Trending: flamegraph-rs / flamegraph: Easy flamegraphs for Rust projects and everything else, without Perl or pipes <3 ★3574

via Rust Trending: launchbadge / sqlx: 🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, SQLite, and MSSQL. ★9239

via Rust Trending: swc-project / swc: Rust-based platform for the Web ★27978

via Alper Çuğun-Gscheidel: Every time I mention slack time as one of the most important things for healthy engineering teams people look at me as if they’re seeing water burning.

via Rust Weekly: Why the “Null” Lifetime Does Not Exist

via Tim Bray: Apparently this just decloaked:

via Kevin Stewart: Ten Years of “Go: The Good, the Bad, and the Meh”

via Rust Weekly: Self-Hosted Cloud Using WebAssembly

via Mark Levison: Backlog Refinement can prevent Zombie Scrum — I love the phrase Zombie Scrum. It conjures to mind teams using the practices of Scrum and getting limited benefit. They ran a workshop with their subscribers to find what was helping them with #ProductBacklogRefinement.

via Zig Weekly: Three Different Cuts: Rust, Go, and Zig

via Axel Rauschmayer: “JSON Type Definition (JTD), or, RFC 8927, is a new standard for defining JSON schemas that has been cooking up since August 2019 and became an experimental RFC in November 2020.”

via Mac Power Users: Ep 701: The Safari Extension Roundup

via Rust Trending: rust-unofficial / awesome-rust: A curated list of Rust code and resources. ★35753

via Yoav Levy: Melody 0.19.0 | A language that compiles to regular expressions and aims to be more easily readable and maintainable

via Rust Weekly: Simple example of building rust code w/ C deps using nix + naersk

via Rust Trending: pingcap / talent-plan: open source training courses about distributed database and distributed systems ★8950

via Rust Trending: microsoft / windows-rs: Rust for Windows ★8689

via Rust Weekly: How rustdoc achieves a genius design

via Terence Eden: 🆕 blog! “The Pull Request Hack is Fucking Magic”

I kind of can’t get this “song” out of my head …

via Kevin Stewart: Gelling your Engineering leadership team

via Rust Trending: Wilfred / difftastic: a structural diff that understands syntax 🟥🟩 ★15143

via Jason Gorman: Another lucky dip from my video channel: 7 Myths of Test-Driven Development Debunked

via Kevin Stewart: Leading vs. Managing in the Engineering World

via Andy Croll: Goodness me @searls has absolutely nailed this. This feels like one of those “well now I have the language to describe it, this is how I think” moments.

via Rust Trending: libp2p / rust-libp2p: The Rust Implementation of the libp2p networking stack. ★3476

via Emily Nakashima: I started my role as VP of Engineering @honeycombio three years ago, and since then I’ve noticed how little candid writing there is about paths to this job or what it actually entails. I’m working on a blog post series about this, and part 1 is out today.

via Cory Doctorow’s linkblog:

Two decades ago, my life changed forever: hearing #BruceSchneier explain that “#security” doesn’t exist in the abstract. You can only be secure from some threat. A fire alarm won’t protect you from burglaries. A condom won’t protect you from mass shootings. It seems obvious, but how often do we hear about “security” without any mention of who is being made secure, and from which threat?

via Mike Bowler: I’ve noticed anecdotally that for a development team, as WIP goes down, quality goes up. I’m thinking my way through how I would visualize that and any suggestions are welcome. I can easily pull WIP numbers out of Jira (all my clients use Jira — sigh). The trick is how to measure quality. Pulling number of bugs entered into Jira can be done but absence of bugs doesn’t prove quality. SonarQube has some technical quality data but quality is more than just code.

via Chris Messina: 👏🏻👏🏻👏🏻

via Rust Trending: tauri-apps / tauri: Build smaller, faster, and more secure desktop applications with a web frontend. ★66400

via Mark Levison: Mise en place of Great Scrum Teams, Christiaan Verwijs — outlines 5 strategies on making refinement better:

via Rust Trending: tikv: Distributed transactional key-value database, originally created to complement TiDB ★13339

via Rust Weekly: Maximizing Your Rust Code’s Performance

via yosh: Oh fun, now watching: “Flux: Liquid Types for Rust.”

via Rust Trending: openobserve: 🚀 10x easier, 🚀 140x lower storage cost, 🚀 high performance, 🚀 petabyte scale - Elasticsearch/Splunk/Datadog alternative for 🚀 (logs, metrics, traces). ★5117

via Rust Weekly: Announcing mailfred 0.1, a library to offer services through the email infrastructure processing emails as requests & responses.

via Rust Weekly: Blog Post: Put a Pin on That

via Nicholas Nethercote: New blog post: Back-end parallelism in the Rust compiler

via Rust Weekly: Fighting Rust Anxiety: Insights from a Go Developer

via Mark Levison: Kent McDonald offers a Kanban Board to visualize your current understanding of the state of the product backlog.

via Boris Mann: We’re hosting a Local-First Software Unconference in St Louis the Saturday after Strange Loop.

via Rust Weekly: vim-doge v4: The Rust Rewrite

via yosh: New blog post: Bridging Fuzzing and Property Testing

via Ryan Trimble: A new blog post about the Scroll-Driven Animations feature coming soon to CSS!

via Rust Weekly: Ubiquity (v0.3.0) - I made a cross-platform markdown editor to learn some Rust. It uses Yew, Tauri, Tailwind and DaisyUI. Currently available on Windows, Linux and the web. (Appears that a Mac version has been added since.)

A fun podcast with lots of command-line tricks.

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

Kent Bull: KERI Tutorial Series — KLI: Sign and Verify with Heartnet

I think I’ve made many of these mistakes over the years:

via Rust Trending: m1guelpf / tinyvector: A tiny embedding database in pure Rust. ★135

via Rust Weekly: Building a Web App in Rust: From Zero to Deployment

via Miguel de Icaza: I have a nerd crush on DocC for documentation. So many good decisions, but also, what an amazing list of features that work out of the box.

via Kevin Stewart: LiteFS Cloud: Distributed SQLite with Managed Backups

via Rust Trending: rustdesk: Virtual / remote desktop infrastructure for everyone! Open source TeamViewer / Citrix alternative. ★43747

Tue Henriksen on LinkedIn: Why Rust is easy

via Rust Trending: dtolnay / proc-macro-workshop: Learn to write Rust procedural macros [Rust Latam conference, Montevideo Uruguay, March 2019] ★2979

via Boa JavaScript engine: Boa just arrived at @fosstodon, so here we have our #introduction. 😋

via Rust Weekly: Zawgl graph database

via @modev: I have started “Rust Atomics and Locks” by Mara Bos.

via Christie Koehler: Oh! That reminds me to share something I’ve found super useful at work. If you’re in a situation where a team’s docs are in markdown spread across a bunch of git repos and you want a unified, searchable interface: mkdocs is your friend.

via nixCraft 🐧: If you ever wanted a visual to explain how binary in works.

via Rust Trending: firecracker-microvm / firecracker: Secure and fast microVMs for serverless computing. ★21924

via allison: A few weeks ago I decided I wanted to be in charge of my own bookmarking infrastructure, so I exported my bookmarks from pinboard and spent the afternoon writing ~500 lines of Python/HTML/CSS/bash to make a lil bespoke database manager/static site generator. Pleased with the results.

via Gankra: We just released the first version of our next release-engineering tool — oranda!

via Rust Weekly: Languages on the rise like Rust and Go are being quite vocal against inheritance and many engineers seem to agree. Why? And is it the fall of inheritance?

via Julia Miocene: Yesterday I posted a new video on my channel.

via Mark Levison: Solid summary article that covers INVEST (Yay), DEEP (good), Definition of Ready (maybe).

via Kevin Stewart:

via Rust Daily: How to think about async/await in Rust

via Kevin Stewart: Better Software Engineering teams — Structures, roles, responsibilities and comparison with common approaches.

Raymii.org: Site update, self-hosted search via pagefind

via Rust Trending: surrealdb: A scalable, distributed, collaborative, document-graph database, for the realtime web ★21210

via Rust Trending: rust-unofficial / awesome-rust: A curated list of Rust code and resources. ★35492

via Rust Weekly: Pixelate images - an intro to Rust and the image crate

via Mark Levison: Silent backlog refinement meetings: a more effective Agile meeting.

Gareth Davies at Parabol: What is Backlog Refinement?

Lars Bergstrom at Google Open Source Blog: Rust fact vs. fiction: 5 Insights from Google’s Rust journey in 2022

via Rust Daily: Building an out-of-tree Rust Kernel Module

via Rasmus Andersson: Playbit is an endeavor to build a new operating system for software creatives. After over two years of research, Playbit is now a real company and I’m hiring Playbit’s founding engineers.

via David Amador: I don’t see it mentioned enough times but Fork is one of the best git clients around imo, lightweight, simple and it just works. Win & Mac, free to try and one time purchase.

Grafbase: How we built the Grafbase local development experience in Rust

A Lemmy instance dedicated to Rust language.

via AWS Bubble: Awesome AWS savvy accounts to follow:

via Dare Obasanjo: Abraham Lincoln famously said “Give me six hours to chop down a tree and I will spend the first four sharpening the ax.”

via Mike Sperber: Easily the best post I’ve read on tech debt.

via jadeforrest: 🧠 FAST agile is the most interesting organizational practice I’ve learned about in a while. Today I share what FAST agile is, and explore whether it’s worth experimenting with.

via Rust Weekly: I was wrong about Unsafe Rust

Programming Language and compiler benchmarks: Rust vs Zig benchmarks: Which programming language or compiler is faster?

Richard Schneeman at Scheems: It’s dangerous to go alone, pub mod use this.rs

via Rust Daily: Effective Rust (35 Specific Ways to Improve Your Rust Code):

Quickwit blog: Observe your Rust application with Quickwit, Jaeger and Grafana

via Rust Trending: spyglass-search / spyglass: A personal search engine: Create a searchable library from your personal documents, interests, and more! ★1824

via Yori Mihalakopoulos: OK, I’m finally releasing the git merge tool that I’ve been working on!

GitHub: jruizaranguren/best-of-digital-identity: A ranked list of awesome Digital Identity open source projects

via Rust Weekly: Google open-sources Rust crate audits

via Rust Weekly: Blog post: Writing Python like it’s Rust

via heckj: @nugmanoff and I have just cut an initial release of YSwift, an MIT licensed open source Swift CRDT library that is powered by the Rust implemention of Yjs.

Poignant read on how demand (“burden” in his wording) inevitably expands to reach and strain capacity, both for computers and humans:

via Rust Weekly: More than 10x faster Rust + Cargo builds with Firebuild cache

via Webdev Weekly: Can Rust Beat JavaScript in 2023?

via Rust Daily: The Rust Performance Book

Via Sam Smith at IIW: A fast memory-based database engine written in C.

via Miguel de Icaza: I liked this observation on open source bubbles.

GitHub: figma/widget-samples: FigJam widget code examples & starter projects using the FigJam Widget API

via Jorge Castro: One day I was complaining to @bketelsen about how I could never quite grok #nix

So he got to work and made https://getfleek.dev

GitHub: VPlugin/VPlugin: A Rust framework to develop and use plugins within your project, without worrying about the low-level details

via Martin Kleppmann: There are now over 150 published papers about CRDTs (let me know if any are missing). Feels like it’s becoming a real field of research!

via Rust Trending: getdozer / dozer: Connect any data source, combine them in real-time and instantly get low-latency Data APIs. All with just a simple configuration! ★633

via Kevin Stewart:

via yosh: Alright, did a final one: the html crate now implements the right content types for each element. This is just the broad categories, not yet the special one-off item kinds. But it should get like 90% the way there!

via Rust Weekly: Modular Errors in Rust — Sabrina Jewson

via Rust Trending: MaterializeInc / materialize: Materialize is a fast, distributed SQL database built on streaming internals. ★4966

via Axel Rauschmayer: Limitations of #Rust strings

via Julia Evans: is there a site like for utf-8? Like where you paste in a UTF-8 string and see how it’s broken up into Unicode code points?

via Rust Weekly: imstr crate: Immutable Strings in Rust (Cheaply Clone-able and Slice-able Strings)

GitHub: dtolnay/no-panic: Attribute macro to require that the compiler prove a function can’t ever panic

via Rust Weekly: garde: a validation library

via Rust Weekly: thiserror, anyhow, or How I Handle Errors in Rust Apps

via Rust Weekly: Blog Post: Rust Is a Scalable Language

via Rust Weekly: NIST added Rust to its list of “Safer Languages” as part of its Software Assurance Metrics and Tool Evaluation

via squillace: #webassembly at the #edge from #wasmio

via Ed Page: clap v4.2.0, with user-styled help descriptions, is now out!

via Rust Weekly: Generators

via Rust Weekly: Is there any AST-level analysis/instrumentation tool for Rust?

Adam Chalmers: Why use Rust on the backend?

via Stefan Baumgartner: Giving zed.dev another spin. It’s fast and it’s beautiful, really. It’s a pleasure to look at it and the original theme is very balanced. It feels very snappy, especially when you get LSP feedback. I miss inlay hints, but I’m sure they will end up one way or another.

via Rust Trending: google / comprehensive-rust: This is the Rust course used by the Android team at Google. It provides you the material to quickly teach Rust to everyone. ★10865

via fruitywelsh: Hello All, with DockerHub removing its free tier and potential for future shenanigans, people are looking to move away from them for free and personal use.

via Rust Weekly: Must move types by Niko Matsakis

via Rust Weekly: Mountpoint — file client for S3 written in Rust, from AWS

via Rust Trending: analysis-tools-dev / static-analysis: ⚙️ A curated list of static analysis (SAST) tools and linters for all programming languages, config files, build tools, and more. The focus is on tools which improve code quality. ★10978

via Rust Weekly: Switching from C++ to Rust

via Rust Weekly: Why is safe version of function faster than unsafe?

via Rust Weekly: Faster than Rust and C++: the PERFECT hash table

via sbmueller: Thanks @nrc for this splendid guide on error handling in Rust. Also much good stuff for error handling in general.

via Rust Trending: meilisearch: A lightning-fast search engine that fits effortlessly into your apps, websites, and workflow. ★34478

via Allan Friedman: This is pretty cool: a brand new free @github tool for creating #SBOM data for your repos. Built on the dependency graph API — supports Go, Rust, NPM, maven, and more. Both CDX and SPDX support!

via Rust Trending: neondatabase / neon: Neon: Serverless Postgres. We separated storage and compute to offer autoscaling, branching, and bottomless storage. ★6825

via Zig Weekly: When Zig is safer and faster than Rust

via Kevin Stewart: Why Turborepo is migrating from Go to Rust — Vercel

“Zero setup” cross compilation and “cross testing” of Rust crates

via Rust Daily: Safety and Soundness in Rust:

via Rust Weekly: Semgrep - Beta support for Rust

via Kevin Stewart: AWS is Asleep at the Lambda Wheel - Last Week in AWS Blog

Via Matt Weagle: First, when you implement RFCs, you will be introducing friction to your team. Instead of going straight to building, we are required to think and write about what we’ll build. Friction brings frustration. Our industry has convinced us that programmers are supposed to be writing code for as much time as possible, leading to negative sentiments to practices that keep programmers away from their editors.

Ecow: Compact, clone-on-write vector and string.

A way to query arbitrary data sources in SQL-like fashion.

Adam Wiggins: The 2.0 release of Automerge is a huge milestone for local-first software. If you’re interested in developing great multi-user, multi-device software without needing massive infrastructure, it’s worth reading this post in full.

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.

Google: For more than a decade, memory safety vulnerabilities have consistently represented more than 65% of vulnerabilities across products, and across the industry. On Android, we’re now seeing something different — a significant drop in memory safety vulnerabilities and an associated drop in the severity of our vulnerabilities.