DSQL just launched support for SEQUENCES and IDENTITY columns. It’s exciting seeing the team launch new features the same week we became available in four new regions.
I wrote a short blog about how we make sure they scale here: blog.benjscho.dev/technical/20...
The cost of turning written business logic into code has dropped to zero. At best, near-zero.
The cost of integrating services and libraries, the plumbing of the code world, has dropped to zero. At best, near-zero.
What does that mean for the future?
New blog post: brooker.co.za/blog/2026/02...
Bernardo as well, he’s great, used to run Amazons internal Rust build system
Blaring ads on gas pumps are the peak of American culture
This sounds great, we have a skill integration that you might find useful!
skills.sh/awslabs/mcp/...
We introduce LeaseGuard: a Raft-specific lease protocol with a precise spec and fast recovery after crashes.
Paper + Implementation linked in our joint (w Jesse @emptysqua.re) blog post below.
muratbuffalo.blogspot.com/2025/12/leas...
TIL (thanks to this paper) that common 64-bit systems are only using 48-bits of that to actually address memory. Still leaving a cool 256TB max addressable size
The Bf-tree paper from VLDB ‘24 looks neat, it’s a shame the implementation hasn’t been released yet. Maybe a chance for someone Christmas tinkering
vldb.org/pvldb/vol17/...
Zig’s fun, I like the explicit error handling and fast compile times. I struggled a bit getting some of the simpler things set up, like reading from a file, mainly because the documentation is lacking in examples for the latest version
Tackling advent of code in Zig this year, my day one solution is up: github.com/Benjscho/aoc...
darryl-ruggles.cloud/dsql-kabob-s...
🆕 Here is my latest blog introducing a Serverless Multi-Region E-Commerce Platform based on an Amazon Aurora DSQL database. For a database platform I have almost always used DynamoDB due to it being truly serverless and pay as you go. (1️⃣/4️⃣)
🧵
My demo from the Amazon Aurora livestream is now up as a VOD on YouTube, you can catch it here: youtu.be/5iFA_7lo9aI?...
What are the best languages for multiprocessor programming right now? Thinking ones that provide strong, safe primitives and good performance.
I know Rust works well for this thanks to ownership & releasing of locks on drop. Are there any others that are worth trying?
I’ve been blowing through Octavia Butler’s Patternists series over the past few weeks. Love how each of them threads together while standing completely on its own.
This blog post from Marc Bowes might help with understanding pricing: marc-bowes.com/dsql-how-to-...
People always ask me “so is AWS using Rust?” Happy to be part of this article shining some light on how Rust is changing the way services are built in AWS.
In a new guest post from #AWS Sr. Principal Engineers @nikomatsakis.com and Mark Bowes take us inside Aurora DSQL's development from scaling write operations without two-phase commit, to overcoming garbage collection hurdles, and embracing Rust. www.allthingsdistributed.com/2025/05/just...
Very glad Steve didn’t follow this advice and that the Rust book exists, it’s an incredible resource
Writing about something you don’t know is often the best way to _start knowing_
I love this paper! It’s a clear way to communicate that both application and infra developers are responsible for how to make things scalable, while splitting those responsibilities neatly
By taking the time to encode some safety property in the type system, you save yourself time and pain down the line in explaining how to use it or preventing misuse
Wrote a short bit about Rust being a “Safe for X” language: blog.benjscho.dev/technical/20...
I’ve basically had this article from lwn in my head for a while and it’s a major reason why I love working in Rust, especially on a big project with a lot of other engineers
Not sure how popular it'll be but I thought this one was pretty good.
smbc-comics.com/comic/precise
![error: avoid using labels containing only the digits `0` and `1` in inline assembly
--> hal-x86_64/src/segment.rs:243:14
|
243 | "1:",
| ^ use a different label that doesn't start with `0` or `1`
|
= help: start numbering with `2` instead
= note: an LLVM bug makes these labels ambiguous with a binary literal number on x86
= note: see <https://github.com/llvm/llvm-project/issues/99547> for more information
= note: `#[deny(binary_asm_labels)]` on by default](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:3zasjiae4xk64hyek5u6jtcx/bafkreiguxn6nenwv5xzygqfd5rsjqfx6kvqjtlwhhxsy3qodeltyshgtpe)
error: avoid using labels containing only the digits `0` and `1` in inline assembly --> hal-x86_64/src/segment.rs:243:14 | 243 | "1:", | ^ use a different label that doesn't start with `0` or `1` | = help: start numbering with `2` instead = note: an LLVM bug makes these labels ambiguous with a binary literal number on x86 = note: see <https://github.com/llvm/llvm-project/issues/99547> for more information = note: `#[deny(binary_asm_labels)]` on by default
why Rust is the greatest programming language of all time, in one screenshot
This is why I’m particularly excited for cargo scripts to be stabilized into Cargo. This is just a single file, it doesn’t really need to be a crate
Rust is a surprisingly great scripting language. While I could fiddle around with bash, awk or see to get something working, without tests it would be more brittle. Rust makes it easy to create a really handy micro utility without spending a lot of time
I’ve been messing around with using Neorg for notes instead of markdown with Obsidian, so I wrote a small converter for all of my existing notes: github.com/Benjscho/md2...
Very nice! I haven’t heard of madsim before, will take a look.
I love working with sim tests, would be very frustrating to do this kind of thing without.
Looks interesting! I’m curious what you’re using for your deterministic sim testing, is it turmoil or something else?
There’s some great quotes in there
“The most successful users adopt a relaxed, sporty attitude”
I’m also really enjoying The Hitchhikers Guide to Logical Verification. It’s dragging up memories of trying to do type inference with Haskell.
