What an interview!
This is an eloquent and candid experience report (plus tech demo) from @roc_lang's most prolific production user.
Niclas has been getting paid to use Roc in production for 2 years (!) even though it's not (quite) at version 0.1.0 yet.
youtu.be/12yVcgQHAK0?si=z2iD…
Tony Hoare on corporate languages and the price of reliability:
"The price of reliability is the pursuit of the utmost simplicity. It is a price which the very rich find most hard to pay."
Brilliant moved CI from GitHub Actions to RWX and builds went from 20–25 min on GHA to ≃3 min on RWX.
That’s an 85% reduction in CI/CD execution time. How it happened ↓
“Agent archaeology”: piecing together why a teammate and their agent wrote code a certain way from scattered commits, transcripts, and conversations.
Richard gave a talk at AI Engineer NYC last month about how we use Delta to avoid it.
youtube.com/watch?v=Enn9dVrR…
Soon, your agents will be able to trace code back to the threads that produced it, giving them access to the decisions and reasoning the code alone can’t explain.
There is an inescapable tradeoff between what a software technology can do (its abilities) and what you know for certain about what it does (its guarantees).
For example:
- Unicode is able to represent strings like `中文🌴`, but ASCII guarantees that all visible characters are exactly one byte.
- Safe rust guarantees an absence of (certain kinds of) memory errors, but it isn't able to encode as many valid programs as unsafe rust can.
- `map` can't do every computation a `foreach` loop can, but `map` always guarantees the output list is the same size as the input list.
- Graphs can represent more kinds of data than DAGs, which represent more than trees, which represent more than lists. But DAGs are orderable, trees have at most one path between nodes, and lists guarantee one order.
The tradeoff exists whether we're talking formats, data structures, languages, or tools. It's so fundamental because it's universal. Give me any software topic and I will give you an example of this tradeoff.
What's causing this? There's a surprisingly simple mathematical explanation! Abilities correspond to `some` quantifiers over a set, while guarantees correspond to `all` quantifiers. `some` is "monotonically true" over the size of the set, meaning when we grow the set, it can flip from false to true but not from true to false. Conversely, `all` is monotonically false, meaning it can flip from true to false but not vice versa.
In other words: to increase a technology's guarantees we need to "shrink the corresponding set", which by definition decreases its abilities.
The ability-guarantee tradeoff is one of the running motifs of my book Logic for Programmers: not the subject of a chapter, but an idea that runs through many chapters. The tradeoff connects diverse topics like testing, optimization problems, and domain-driven design. If this interests you, the book is available in pdf, epub, and print formats. Check the link below!
logicforprogrammers.com/
(Or, if you want to participate in the November charity drive, check out the link in the next Tweet!)
We had to build a new editor to make Delta threads work. Foolishly, we thought it'd be simple.
... but turns out, we had to start from scratch (six times).
delta.dev/blog/building-a-th…
Dijkstra on testing vs language design:
"For what program structures can we give correctness proofs without undue labor?"
With @elmlang you get:
- no null pointers
- no unhandled exceptions
- no aliasing bugs
- safety from supply chain attacks
AND it's more fun than JS/TS 😅
A CVE (Common Vulnerabilities and Exposures) is a publicly disclosed security flaw.
They increased following a slight upward slope all the way to early 2024, when there was a sudden small increase... then starting in 2026, we went full exponential.
In most instances, the vulnerabilities were pre-existing, so much of the increase is just our better ability to find the faults.
This is of historical importance. We have never witnessed anything of the sort.
I don't think version control for agents will be solved by making Git backends faster or forcing collaboration onto one machine in the cloud. It needs a more ambitious primitive.
We've spent the last 12 months building one. So excited to share how DeltaDB works under the hood!
DeltaDB is a new, Git-compatible version control system for agent context. It keeps every edit linked to the conversation that produced it.
@as__cii takes a deep dive into how we built it with Rust, SQLite, and Durable Objects:
delta.dev/blog/fine-grained-…
DeltaDB is a new, Git-compatible version control system for agent context. It keeps every edit linked to the conversation that produced it.
@as__cii takes a deep dive into how we built it with Rust, SQLite, and Durable Objects:
delta.dev/blog/fine-grained-…