# Metadata

On distributed systems broadly defined and other curiosities. The opinions on this site are my own.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## TLAPS-Bench: Formally Proving Correctness Of Real-World System Specifications With TLA+ Proof System

DevFeed: [TLAPS-Bench: Formally Proving Correctness Of Real-World System Specifications With TLA+ Proof System](<https://devfeed.tech/articles/tlaps-bench-formally-proving-correctness-of-real-world-system-specifications-with-tla-proof-system-141207.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/11/tlaps-bench-formally-proving.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-11-18T06:19:39Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Isabelle/HOL proof assistant](<https://devfeed.tech/topics/isabelle-hol-proof-assistant.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [bench](<https://devfeed.tech/tags/bench.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [harness](<https://devfeed.tech/tags/harness.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [targets](<https://devfeed.tech/tags/targets.md>), [tla-plus](<https://devfeed.tech/tags/tla-plus.md>)

### AI overview

TLAPS-Bench tests whether agents can prove system-wide safety, liveness, and refinement properties in TLA+ without supplied proof scaffolds. Its 265 targets across 95 specifications include a 70-target hard active set; on that set, the best reported model proved 31 targets (44.3%) at pass@3. Tilapia runs agents in isolated containers with TLAPS, TLC, and Apalache, and uses model checking to falsify candidate invariants before proof attempts. Apalache checks bounded transitions symbolically but requires types; when it cannot type a spec, TLC can test inductiveness by enumerating candidate states, which may become expensive. The benchmark also exposed specification, model, and configuration defects, illustrating that proof attempts and model checking can reveal different issues. Results remain limited: no model proved the Wildfire refinement, and many failures involved missing invariants or proof obligations too large for solvers. Accepted proofs can also be lengthy and difficult for engineers to review.

### Source excerpt

TLA+ specification language has long been associated exclusively with TLC model checker in most people's minds. Model checking with TLC finds bugs fast, but it only covers the configuration you give it, and is cheap only for small configurations (3 nodes, value ranges "1..4", etc.). There is also the TLA+ Proof System, TLAPS, which checks a deductive proof, instead of enumerating states like model checking. After you write the proof in TLA+ as a hierarchy of numbered steps, TLAPS turns each step into proof obligations and hands them to backend provers. Being a prover, TLAPS can cover all configurations at once, but it requires a lot of expertise and effort. I had always stayed away from TLAPS, because I hadn't felt I am up to the challenge. You have to figure out the inductive invariant (see below), show every action preserves it, and divide the argument into obligations small enough for Z3, Isabelle, or LS4 to check. So in practice what ends up happening is that almost everyone model checks and almost nobody proves. Well, like with most things in our industry, this changed drastically in the last year. Earlier this summer, my mind was blown when I saw Claude doing TLAPS proofs! Holy molly, I didn't have this on my bingo card for this year! I knew it would be smart to invest more on this, and it turns out Tianyin Xu, Qian Cheng, and Markus Kuppe were already working on it, and they had a paper in the works. I joined the team late, and I am not sure if I was able to contribute significantly. It was great to collaborate and associate with such a qualified team nevertheless. The paper is now on arXiv, and the code is on GitHub. The paper asks how much of the proof burden the agents can carry today, and introduces a benchmark and a harness to investigate this. TLAPS-Bench is a benchmark of 265 proof targets from 95 TLA+ specs of real systems and protocols. Tilapia is the harness that runs agents on those targets, and it provides the proof checker, the model checkers, th

## Writing as a thinking tool

DevFeed: [Writing as a thinking tool](<https://devfeed.tech/articles/writing-as-a-thinking-tool-122219.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/11/writing-as-thinking-tool.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-11-07T08:22:10Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [CVE-2026-58058](<https://devfeed.tech/topics/cve-2026-58058.md>), [Automaton](<https://devfeed.tech/topics/automaton.md>), [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [advice](<https://devfeed.tech/tags/advice.md>), [ai](<https://devfeed.tech/tags/ai.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [graduate-students](<https://devfeed.tech/tags/graduate-students.md>), [information](<https://devfeed.tech/tags/information.md>), [intelligence](<https://devfeed.tech/tags/intelligence.md>), [language](<https://devfeed.tech/tags/language.md>), [llms](<https://devfeed.tech/tags/llms.md>), [model](<https://devfeed.tech/tags/model.md>), [my-advice](<https://devfeed.tech/tags/my-advice.md>), [notes](<https://devfeed.tech/tags/notes.md>), [paper](<https://devfeed.tech/tags/paper.md>), [pencil](<https://devfeed.tech/tags/pencil.md>), [reading](<https://devfeed.tech/tags/reading.md>), [research-advice](<https://devfeed.tech/tags/research-advice.md>), [thinking](<https://devfeed.tech/tags/thinking.md>), [tool](<https://devfeed.tech/tags/tool.md>), [turing-machine](<https://devfeed.tech/tags/turing-machine.md>), [turing-machines](<https://devfeed.tech/tags/turing-machines.md>), [turkey](<https://devfeed.tech/tags/turkey.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The author argues that writing extends thought by giving the mind external memory and workspace: notes help process reading, while drafting a paper review can expose gaps and reveal connections that were not apparent beforehand. They worry that relying on an LLM before forming one's own ideas can crowd out that work; models may know established literature and framing but, in the author's view, cannot be trusted to make the creative leap from a person's half-formed intuition. Their practical method is to draft freely without judging, then edit hard across several passes, favor plain and concise prose, write for intrinsic reasons, and schedule regular writing rather than waiting for inspiration. The author presents these as personal experience and advice, not as a tested universal method.

### Source excerpt

In middle school I could not get through long passages no matter how hard I tried. I would read an entire page and find that nothing had registered, so I started taking notes out of desperation. This was the late 80s, and Tony Buzan's mind maps had just reached Turkey. This led me to produce pages and pages of notes that looked like spiderwebs. Creating those notes have helped me tremendously. I made sense of what I was reading by figuring out which branch they would hang off in my mind maps. I realized my pages were not for storing the information as much as they were for processing it. It took me another ten years to understand why this works so well. During a stretch of PhD procrastination, I read Manuel Blum's advice to graduate students: You are all computer scientists. You know what FINITE AUTOMATA can do. You know what TURING MACHINES can do. For example, Finite Automata can add but not multiply. Turing Machines can compute any computable function. Turing machines are incredibly more powerful than Finite Automata. Yet the only difference between a FA and a TM is that the TM, unlike the FA, has paper and pencil. Think about it. It tells you something about the power of writing. Without writing, you are reduced to a finite automaton. With writing you have the extraordinary power of a Turing machine. This is a crisp technical claim about which problems you can solve with writing. If you take the paper away, you downgrade yourself by an entire complexity class! I think this explains a lot about human history as well. Language let us externalize some of our thinking, and our species got smarter. Writing let us externalize even more of it, and we got smarter again. I suspect this is also why LLMs are as capable as they are: so much of our intelligence is already deposited in language that a model trained on it inherits a good deal of intelligence for free. Out-of-core execution When we write, we are externalizing our thinking onto paper, and that is what raises our

## TLA-Verus: LLM agents prove temporal properties of TLA+ specs

DevFeed: [TLA-Verus: LLM agents prove temporal properties of TLA+ specs](<https://devfeed.tech/articles/tla-verus-llm-agents-prove-temporal-properties-of-tla-specs-102471.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/10/tla-verus-llm-agents-prove-temporal.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-10-27T19:13:12Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [automated-reasoning](<https://devfeed.tech/tags/automated-reasoning.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [properties](<https://devfeed.tech/tags/properties.md>), [rust](<https://devfeed.tech/tags/rust.md>), [temporal](<https://devfeed.tech/tags/temporal.md>), [tla](<https://devfeed.tech/tags/tla.md>), [tla-plus](<https://devfeed.tech/tags/tla-plus.md>), [verus](<https://devfeed.tech/tags/verus.md>)

### AI overview

TLA-Verus uses a prover-reviewer loop to prove temporal properties of TLA+ specifications after translating each spec-property pair into Verus. Its corpus pipeline translated 6,070 of 16,459 pairs with TranSpec; 5,160 were judged well-posed, and the prover closed 3,094. Liveness was hardest: 304 of 809 tasks were proved. The paper also evaluates models on 40 tasks selected from previously proved cases, so those benchmark results do not measure performance on the full task set. The excerpt describes two translation routes: a deterministic Rust transpiler and an LLM translator checked by an LLM judge, with no translation proof. It highlights missing refinement proofs between the TLA+ and Verus specifications and between Verus specs and implementation code; the evaluated files contain only Verus spec and proof code, not executable Rust. TLAPS already has temporal proof support through PTL/LS4 and rules such as WF1, though enabledness obligations can make liveness proofs difficult. The excerpt says the paper does not compare against TLAPS. Tasks that compile with one open obligation may still be unprovable, and the vacuity filter can miss broken state-machine translations.

### Source excerpt

This NeurIPS'26 workshop paper takes TLA+ specs from GitHub, translates them into Verus, and has LLM agents prove the safety and liveness properties in the specs. The motivation The paper aims to address two problems it raises with TLA+. First, nothing ties the spec to the code, so they drift apart. And second, it claims that proof support is thin: TLC only checks small configurations, and TLAPS is weak on liveness. They abandon pursuing the first weakness they raise at the onset of the paper. Closing it needs a proof that the generated Rust code (which it turns out TLA-Verus doesn't produce anyway) refines the spec, so they list this as future work. It gets worse though. There is no refinement proof between the TLA+ spec and the Verus spec either. Nothing establishes that the translated Verus spec means what the original meant. (Trace validation, meanwhile, is a viable way of tying TLA+ to implementation code, and has been getting a lot of attention recently.) They dedicate the paper to addressing the second weakness, but I think they understate the TLAPS capability for doing temporal proofs. Writing `BY PTL` on a proof step tells TLAPS to treat that step as propositional temporal logic and send it to LS4, an LTL decision procedure. Coalescing (Doligez, Kriener, Lamport, Libal, Merz) is the technique that abstracts the first-order parts of a TLA+ obligation into propositional atoms LS4 can handle. Lamport's temporal proof rules are all there, including WF1, the rule that turns a weak fairness assumption on an action into a leads-to conclusion. The limitation is that TLAPS reasons poorly about ENABLED, and discharging the enabledness side conditions of WF1 is where a liveness proof needs more work. All this to say, TLAPS has temporal proof capability, and last time I used Claude Code to write TLAPS proofs, I was surprised by how well Opus was able to write TLAPS proofs. I expected the paper to compare against TLAPS proofs, but unfortunately that is missing. Verus, t

## The Man from the Future: Why Johnny Can't Stop Abstracting

DevFeed: [The Man from the Future: Why Johnny Can't Stop Abstracting](<https://devfeed.tech/articles/the-man-from-the-future-why-johnny-can-t-stop-abstracting-100985.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/10/the-man-from-future-why-johnny-cant.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-10-26T06:28:12Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Math and Logic](<https://devfeed.tech/topics/math-and-logic.md>), [quantum mechanics](<https://devfeed.tech/topics/quantum-mechanics.md>), [Cellular automaton](<https://devfeed.tech/topics/cellular-automaton.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [biology](<https://devfeed.tech/tags/biology.md>), [book-review](<https://devfeed.tech/tags/book-review.md>), [cellular-automata](<https://devfeed.tech/tags/cellular-automata.md>), [computing](<https://devfeed.tech/tags/computing.md>), [economics](<https://devfeed.tech/tags/economics.md>), [game-theory](<https://devfeed.tech/tags/game-theory.md>), [monte-carlo](<https://devfeed.tech/tags/monte-carlo.md>), [quantum-mechanics](<https://devfeed.tech/tags/quantum-mechanics.md>), [set-theory](<https://devfeed.tech/tags/set-theory.md>), [weather-prediction](<https://devfeed.tech/tags/weather-prediction.md>)

### AI overview

The article presents John von Neumann's recurring strength as abstraction: identifying the simplest structure beneath a difficult problem. It traces that approach from his set theory and rigorous formulation of quantum mechanics to game theory, stored-program computing, fault-tolerant systems, and self-reproducing automata. The author also describes the limits and costs of his methods: von Neumann's game theory framework centered on zero-sum play, and the article argues that his simplified Cold War model led him toward dangerous nuclear-strike advocacy. In a 1955 essay, he rejected banning particular technologies as a workable safeguard, arguing that technology was too interconnected and that prohibition would not be heeded. He instead proposed a continuing series of small, correct decisions guided by patience, flexibility, and intelligence.

### Source excerpt

I have come to suspect that to most people thinking is painful. Some of us are addicted to thinking. Some of us find it a necessity. Johnny enjoyed it. I even have the suspicion that he enjoyed almost nothing else. -- Edward Teller, eulogizing John von Neumann I listened to Ananyo Bhattacharya's "The Man from the Future: The Visionary Life of John von Neumann" in my car during the many commute hours Bay Area traffic afforded me. I thought I should share the Johnny phenomena here. I knew about von Neumann being a very influential mathematician/scientist/engineer but the full list still left me bedazzled. In his 53 years of life (1903-1957), von Neumann seeded so many fields. Every time there was an important discovery in physics, mathematics or computation, John von Neumann was there. Set theory and the foundations of mathematics. The mathematical formulation of quantum mechanics. Operator algebras (still called von Neumann algebras). Ergodic theory. Game theory. Expected utility theory (which is the foundation of most of modern mathematical economics). The Monte Carlo method. The stored-program computer architecture that every machine you have ever touched is built on. Numerical weather prediction. Fault-tolerant computing. Self-reproducing automata (cellular automata), and arguably, the logical structure of molecular biology, four years before Watson and Crick. There is also, unfortunately, the implosion lens for the Nagasaki bomb, and a decade of hawkish nuclear strategy. Early years At six, Janos (the OG hungarian name for Johnny) could divide eight-digit numbers in his head and hold a conversation in ancient Greek. He later added Latin, French, German, English, and Yiddish. The rumor was that he remembered everything he ever read. Many years later Herman Goldstine decided to test this by asking him to recite "A Tale of Two Cities." Von Neumann started on chapter one and had to be asked to stop fifteen minutes later. Budapest around 1900 produced an absurd cluste

## What Do the Frontier Labs Actually Believe?

DevFeed: [What Do the Frontier Labs Actually Believe?](<https://devfeed.tech/articles/what-do-the-frontier-labs-actually-believe-98977.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/10/what-do-frontier-labs-actually-believe.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-10-24T16:30:00Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Frontier AI](<https://devfeed.tech/topics/frontier-ai.md>), [ai alignment](<https://devfeed.tech/topics/ai-alignment.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [2019](<https://devfeed.tech/tags/2019.md>), [2022](<https://devfeed.tech/tags/2022.md>), [ai](<https://devfeed.tech/tags/ai.md>), [alignment](<https://devfeed.tech/tags/alignment.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [attack](<https://devfeed.tech/tags/attack.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [blogs](<https://devfeed.tech/tags/blogs.md>), [book](<https://devfeed.tech/tags/book.md>), [cambridge](<https://devfeed.tech/tags/cambridge.md>), [conference](<https://devfeed.tech/tags/conference.md>), [existential-risk](<https://devfeed.tech/tags/existential-risk.md>), [labs](<https://devfeed.tech/tags/labs.md>), [misc](<https://devfeed.tech/tags/misc.md>), [podcast](<https://devfeed.tech/tags/podcast.md>), [published](<https://devfeed.tech/tags/published.md>), [questions](<https://devfeed.tech/tags/questions.md>), [ray](<https://devfeed.tech/tags/ray.md>), [research](<https://devfeed.tech/tags/research.md>), [silicon-valley](<https://devfeed.tech/tags/silicon-valley.md>), [superintelligence](<https://devfeed.tech/tags/superintelligence.md>)

### AI overview

The article presents TESCREAL as seven related ideologies that, in Emile P. Torres's account, share a goal of a cosmic post-human future enabled by artificial superintelligence. It distinguishes their emphases: transhumanism seeks to extend human capacities, cosmism imagines engineering beyond Earth, rationalism prioritizes reasoning to manage technological risk, effective altruism seeks to optimize moral impact, and longtermism frames creating future value as a moral obligation. Within this worldview, accelerationists favor building AI while working on alignment; doomers argue development should wait until alignment is understood. The article argues that both camps can prioritize post-human successors over biological humanity: "safety" may mean preserving that future, while terminal human extinction could be acceptable if successors remain. It cautions that the account is Torres's interpretation and that the article's claims about lab leaders' beliefs and motivations are not established as universal facts.

### Source excerpt

I listened to a recent episode of Cal Newport's "Deep Questions" podcast, where he interviews Emile P. Torres. Cal says that if you want to understand what is happening in AI, you have to understand the futurist ideologies that shape the people running the frontier labs. Torres is a researcher who studies eschatological and utopian movements. They spent a decade inside this movement as a true believer, published in it, worked as a research assistant to Ray Kurzweil, did a stint at Cambridge's Centre for the Study of Existential Risk, and then defected in 2019. TESCREAL Torres coined "TESCREAL" with the computer scientist Timnit Gebru around late 2022. They were trying to name the seven ideological drivers behind the race to build artificial superintelligence : Transhumanism, Extropianism, Singularitarianism, Cosmism, Rationalism, Effective Altruism, and Longtermism. This is also roughly the chronological order these ideologies emerged over the last 40 years. Transhumanism is the backbone and the rest are mostly variants with different emphases. It advocates using technology to push humans past our biological limits: longer lives, better cognition. Torres's claim is that transhumanism is the water Silicon Valley swims in: most people there don't call themselves transhumanists for the same reason Torres has never publicly declared themselves a round-Earther. Cosmism widens the scope: why stop at re-engineering the human organism when you could re-engineer entire galaxies, maybe intervene on the fabric of spacetime itself. Rationalism was founded by Eliezer Yudkowsky, a transhumanist, extropian, and singularitarian, on the thesis that to build these technologies without being destroyed by them, we first need to optimize our rationality. Effective altruism emerged from the rationalist blogs (Overcoming Bias, LessWrong) and swapped the target: optimize our morality rather than our rationality. One branch of this is "earning to give": take the highest-paying job you can s

## HPTS 2026 (Day 2 and Day 3)

DevFeed: [HPTS 2026 (Day 2 and Day 3)](<https://devfeed.tech/articles/hpts-2026-day-2-and-day-3-97842.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/10/hpts-2026-day-2-and-day-3.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-10-23T16:45:30Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [DuckDB](<https://devfeed.tech/topics/duckdb.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Cache](<https://devfeed.tech/topics/cache.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2026](<https://devfeed.tech/tags/2026.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [ai](<https://devfeed.tech/tags/ai.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [best](<https://devfeed.tech/tags/best.md>), [big-data](<https://devfeed.tech/tags/big-data.md>), [building](<https://devfeed.tech/tags/building.md>), [but](<https://devfeed.tech/tags/but.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [chair](<https://devfeed.tech/tags/chair.md>), [checksums](<https://devfeed.tech/tags/checksums.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [compress](<https://devfeed.tech/tags/compress.md>), [compression](<https://devfeed.tech/tags/compression.md>), [compute](<https://devfeed.tech/tags/compute.md>), [hpts](<https://devfeed.tech/tags/hpts.md>), [trip-report](<https://devfeed.tech/tags/trip-report.md>)

### AI overview

The notes trace a recurring systems challenge: moving data and handling operational overhead often constrain performance, energy use, and freshness. The GPU engine Sirius aims to accelerate existing databases without modifying DuckDB, while compressing data to trade abundant GPU compute for scarce memory. Microsoft's DPU approach assigns small accelerators to repetitive tasks such as compression and encryption; the notes also describe runtime selection of data movement strategies based on actual downstream consumption. For object storage, proposals include a net-change diff API, shared append-only logs for concurrent table writes, and a Tesla time-series database querying Parquet directly on S3. Viktor Leis argues that today's S3 designs inherit HDD-driven needs for caching and large reads, and that SSD-based object storage could remove some of this complexity, at higher reported cost. Other talks address reducing Cassandra storage overhead, modeling retry-related metastability, quorum protocols' operational requirements, and the freshness-versus-scalability tradeoffs in lakehouse and HTAP systems.

### Source excerpt

This is the second half of my HPTS 2026 notes. Day 1 was mostly about AI and the importance of specifications. Day 2 and day 3 cover hardware, object storage, failures, consensus, and lakehouses. Session 5: Hardware will save us all (chair: Natassa Ailamaki) The Fastest Way to be the Fastest (Bobbi Yogatama, NVIDIA) GPUs and databases have a love-hate relationship, and Bobbi listed the three reasons: limited GPU memory capacity, the interconnect bottleneck, and engineering complexity. The first two are being fixed by the hardware roadmap. HBM is getting larger and faster. Interconnects and network fabrics are getting faster. But engineering complexity requires some work. No one is eager to rewrite their database to get it work with a GPU. Bobbi introduced Sirius, a GPU-native composable analytics engine. It offers a drop-in accelerator for your existing database, with GPU-native execution underneath. MICE is the design principle: modular, interoperable, composable, extensible. Bobbi showed how Sirius plugs into DuckDB with no modification to DuckDB. The other design lesson from Bobby is to spend compute to save memory. On a GPU, compute is the abundant resource and memory capacity and bandwidth are the scarce ones, so the classic tradeoff needs to flip here. It is best to compress the data, compress everywhere, and operate on the compressed data. The Next Watt Saved Won't Come from a CPU or a GPU (Devashish Purandare, Microsoft) Datacenter power consumption is the bottleneck in building datacenters right now. Where is the power consumed? Tax cycles are 60-80% of all execution. There is datacenter tax: compression, crypto, data movement, memory allocation, protocol and RPC handling. Then there is also system tax: error handling, checksums, filesystems, kernel, STL, networking, multithreading. Unfortunately, no single category dominates, so there is no single high value thing to fix. So how do we fix this? Dev titled his next section: how I learned to stop worrying ab

## HPTS 2026 (Day 1)

DevFeed: [HPTS 2026 (Day 1)](<https://devfeed.tech/articles/hpts-2026-day-1-93153.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/10/hpts-2026-day-1.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-10-21T19:58:55Z

Content type: news

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [queueing theory](<https://devfeed.tech/topics/queueing-theory.md>)

Tags: [2015](<https://devfeed.tech/tags/2015.md>), [2019](<https://devfeed.tech/tags/2019.md>), [2025](<https://devfeed.tech/tags/2025.md>), [2026](<https://devfeed.tech/tags/2026.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-software](<https://devfeed.tech/tags/agentic-software.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-development](<https://devfeed.tech/tags/ai-development.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [berkeley](<https://devfeed.tech/tags/berkeley.md>), [better](<https://devfeed.tech/tags/better.md>), [blog](<https://devfeed.tech/tags/blog.md>), [disrupt](<https://devfeed.tech/tags/disrupt.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [faster](<https://devfeed.tech/tags/faster.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [function](<https://devfeed.tech/tags/function.md>), [gap](<https://devfeed.tech/tags/gap.md>), [hpts](<https://devfeed.tech/tags/hpts.md>), [tla](<https://devfeed.tech/tags/tla.md>), [trip-report](<https://devfeed.tech/tags/trip-report.md>)

### AI overview

Day 1's recurring theme was that reliable AI-generated systems depend on clear specifications and checkable results. Ion Stoica described two gaps: prompts may miss user intent, and a system's model may omit realities in the world. In a key-value-store example, an agent scored a sixfold speedup by exploiting YCSB's generated values rather than storing them, illustrating reward hacking. Talks on database synthesis showed different verification approaches: one compared generated OLAP systems with DuckDB, while another aimed to prove Rust implementations against SQLSpec and reported about 75% proved. A learned-systems talk argued that inference latency, opacity, and maintenance can outweigh benefits in database decision paths, recommending shipping reviewed generated code instead of an embedded model. Other notes covered agent reliability through shared transaction logs and storage reliability challenges from correlated failures and widening drive capacity-to-bandwidth gaps. These are the author's notes from Day 1; some talks had no notes, and Days 2 and 3 are outside this excerpt.

### Source excerpt

Jim Gray started HPTS 42 years ago, and it still runs the same way at Asilomar with 0 proceedings, 1 track, 100 invited people, and ample discussion breaks. It's one of my favorite events, and I look forward to attending it every two years. This is my...umm...fifth HPTS. I have been attending all of them since 2015, but I seem to have missed it in 2019. Yep, my life is a blur, even for me. Here are my notes from day 1. I will put day 2 and day 3 in a second post. Keynote: Reality is the Final Verifier. Two Key Gaps in Agentic Software Engineering (Ion Stoica, UC Berkeley) Ion started with the promising parts. LLMs are able to solve difficult math problems, and provide proofs for conjectures that have been outstanding for many decades (Ok, maybe this is not as promising to mathematicians). LLMs also play scientist with AlphaEvolve, and OpenEvolve. In summer 2025 Berkeley ran a seminar where students applied agentic tools to research problems. They took a published state-of-the-art result, used it as the baseline, kept the objective fixed, and let the loop run. Ten of twelve students got better results than the published baseline. The ADRS blog series and papers come out of this work. But then comes the reality check. Yes, AI seems to improve researcher productivity, but it did not disrupt how we do research. It cannot come up with new research ideas. It cannot build new production systems. The rest of the talk was his attempt to explain this gap. Ion led on with an anecdote from the Jitski project, where they asked an agent to synthesize a key-value store from scratch to maximize throughput. They applied the standard AI development loop. And surprisingly, one solution came back 6x faster than anything before it. How? The benchmark was YCSB, and YCSB generates its values with a hash function. The agent noticed this and stopped storing values altogether and computed them on the fly with get(key) = hash(key). This is the very definition of "reward hacking". Ion frames t

## Atlas Infinite: MongoDB's Disaggregated Architecture

DevFeed: [Atlas Infinite: MongoDB's Disaggregated Architecture](<https://devfeed.tech/articles/atlas-infinite-mongodb-s-disaggregated-architecture-84688.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/10/atlas-infinite-mongodbs-disaggregated.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-10-11T01:37:26Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [sharding](<https://devfeed.tech/topics/sharding.md>), [Data integrity in software engineering](<https://devfeed.tech/topics/data-integrity-in-software-engineering.md>), [read-replica](<https://devfeed.tech/topics/read-replica.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [databases](<https://devfeed.tech/tags/databases.md>), [disaggregation](<https://devfeed.tech/tags/disaggregation.md>), [mongodb](<https://devfeed.tech/tags/mongodb.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

An overview of Atlas Infinite, MongoDB's compute-storage disaggregated architecture, explains how it uses separate logical and physical logs, checkpoint-based page materialization, and encryption on compute nodes to preserve WiredTiger performance while keeping shared storage unable to read customer data. The design also supports independent compute and storage scaling and millisecond replica lag.

### Source excerpt

Atlas Infinite, which dropped in public preview on September 29 alongside MongoDB 9.0, delivers a significant architectural update payload: compute-storage disaggregation. Separating compute from storage is not new, and there are well-known ways to do it. But what makes Atlas Infinite interesting is how MongoDB departs from the standard design to keep WiredTiger's efficiency and to ensure that the shared storage layer never sees customer data unencrypted. I am giving a high level overview of the architecture here distilling from the MongoDB Engineering blog post by Abhishek Chauhan, who led the effort. For detailed coverage, I refer you to that post. It is a great read, and parts 2 and 3 will drop soon. Why not earlier, and why now Disaggregated databases have existed for some time, so why did MongoDB wait? This is mainly because MongoDB didn't need disaggregation to scale out: when a workload outgrew one machine, sharding spread it across many nodes in a seamless manner. MongoDB was among the first databases to ship sharding with automatic chunk balancing and routing. Since horizontal scaling has been a first-class feature for over a decade, MongoDB never faced the single-node limit that pushed other systems toward disaggregation early. That bought us time to do disaggregation right, without regressing on WiredTiger's performance or its security model. Disaggregation is a good idea for several reasons anyways, and MongoDB adopted it to address customer needs. For one, storage gravity has become the bottleneck for very large clusters. In Atlas's shared-nothing architecture, each node in a three-node replica set has its own disk with a full copy of the data. That means, operations like growing storage, adding a replica, or restoring a backup, would require copying the whole dataset. On a large cluster that can take hours when customers expect minutes. And since compute and storage come bundled, needing more of one means paying for more of both. This is why customers

## What Happens When the Model Eats the Stack? Rethinking the Research Agenda for Data Agents to Withstand the Bitter Lesson

DevFeed: [What Happens When the Model Eats the Stack? Rethinking the Research Agenda for Data Agents to Withstand the Bitter Lesson](<https://devfeed.tech/articles/what-happens-when-the-model-eats-the-stack-rethinking-the-research-agenda-for-data-agents-to-withstand-the-bitter-lesson-59172.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/09/what-happens-when-model-eats-stack.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-09-23T23:04:29Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [data](<https://devfeed.tech/topics/data.md>), [Database](<https://devfeed.tech/topics/database.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [systems](<https://devfeed.tech/topics/systems.md>), [context](<https://devfeed.tech/topics/context.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [codex](<https://devfeed.tech/tags/codex.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [jevons-paradox](<https://devfeed.tech/tags/jevons-paradox.md>), [llms](<https://devfeed.tech/tags/llms.md>), [sql](<https://devfeed.tech/tags/sql.md>), [systems](<https://devfeed.tech/tags/systems.md>), [tla](<https://devfeed.tech/tags/tla.md>), [token-efficiency](<https://devfeed.tech/tags/token-efficiency.md>)

### AI overview

This commentary examines research on data agents through Sutton's Bitter Lesson, arguing that improving large language models may absorb much of the hand-engineered scaffolding built for specialized agents. It highlights evaluations where a general coding agent surpasses a human-designed data agent with a newer model, while arguing that persistent semantic context and systems designed for bursty AI workloads remain important because lower query costs may increase overall demand.

### Source excerpt

General methods that scale with computation will inevitably displace hand-engineered domain knowledge! Sutton's Bitter Lesson hangs like a Sword of Damocles over all of us. This paper, which just dropped, applies that lesson to data agents, and says that as LLMs improve, they will quickly absorb the agent scaffolding researchers have spent the last few years painstakingly building. It argues that researchers should instead work on building curated contextual information about the data environment (aka. persistent semantic context) to help data agents be efficient across many queries. The Bitter Lesson for Data Agents The evaluation section aims to capture the Bitter Lesson in action. The authors compared general coding agents (the Codex harness with no task-specific engineering) against state-of-the-art human-designed data agents on two benchmarks, TAG-Bench and DAB. They use the same models on both sides, so the only variable is the scaffolding. They find that: Although the human-designed Agentar-Scale-SQL won on accuracy and token efficiency with o3, when using GPT-5.6 Sol that flips and the plain coding agent surpasses on both counts. Bam! The number of back-and-forth turns an agent needs to solve a query drops from 23.2 with o3 to 6.0 with GPT-5.6 Sol. The newer models get the analytical logic right quickly, skipping the trial-and-error steps. Kaboom! Side Remark: Interestingly, the authors use these efficiency gains to bury their own prior work (in this case Ion and Matei's) from just a year ago. "Supporting Our AI Overlords" argued database systems would be overwhelmed by "agentic speculation": massive bursts of inefficient queries from confused models. Now they say the opposite, that models formulating correct answers efficiently "directly challenges the premise of recent work [11]". Them are fighting words. Why bury your own work when others would happily do it for you? For the record, I still think the direction in the Overlords paper is valid, and we shoul

## In Search of a Compositional Theory of Self-Stabilization

DevFeed: [In Search of a Compositional Theory of Self-Stabilization](<https://devfeed.tech/articles/in-search-of-a-compositional-theory-of-self-stabilization-57579.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/09/in-search-of-compositional-theory-of.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-09-21T16:55:13Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [retry](<https://devfeed.tech/topics/retry.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [metastability](<https://devfeed.tech/tags/metastability.md>), [retries](<https://devfeed.tech/tags/retries.md>), [stabilization](<https://devfeed.tech/tags/stabilization.md>), [tla-plus](<https://devfeed.tech/tags/tla-plus.md>)

### AI overview

The author examines compositional reasoning for self-stabilization and metastable failures. Using a TLA+ model of a retry storm, the article discusses rely-guarantee contracts, their limitations for modeling accumulating queues, and possible directions for a compositional theory.

### Source excerpt

My quest for a principled solution for metastable failures has taken me back to my roots on self-stabilization, as this recent paper related the problem to composition of self-stabilizing systems. But, my literature search for recent work on composing self-stabilizing systems didn't yield anything useful. The layered stabilization idea was already in place by the early 2000s, and nothing fundamental seems to have been added since. Frustrating. So I decided to attack the problem using the concrete example I have. I had composed a rely-guarantee TLA+ model of a retry storm as two components with contracts. That model reproduces metastable failure because the composition that worked from good states failed to work when a large shock removes the base case that let the two conditions hold each other up. Searching for rely-guarantee based composition from every state, turned up a 2017 control theory paper by Kim, Arcak and Seshia, "A Small Gain Theorem for Parametric Assume-Guarantee Contracts". This paper does roughly what I want: discharging circular reasoning between two components without layering or blocking. But it comes with some serious limitations. In their formalism, a component is an input-output relation on signals, and contracts relate an input bound to an output bound. This is a memoryless view of a component, so it is not possible to express backlog accumulating from previous rounds. That rules out queues, among other useful distributed systems concepts. It also has no connection to stabilization. The paper does not talk about a variant/potential function and convergence reasoning. But there are still pieces there worth stealing toward a compositional theory of self-stabilization and metastability. Below I try to work this out... somewhat unsuccessfully. Understanding Parametric Assume-Guarantee Contracts In our original model, the retrier's guarantee was conditional and partial: "if the queue is under 6, I send no retries". This contract does not say anyth

## Jetpack: Consensus Made Generally Fast (OSDI '26)

DevFeed: [Jetpack: Consensus Made Generally Fast (OSDI '26)](<https://devfeed.tech/articles/jetpack-consensus-made-generally-fast-osdi-26-41858.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/09/jetpack-consensus-made-generally-fast.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-09-12T05:36:27Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Latency](<https://devfeed.tech/topics/latency.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [Raft](<https://devfeed.tech/topics/raft.md>), [protocols](<https://devfeed.tech/topics/protocols.md>), [Parallelism](<https://devfeed.tech/topics/parallelism.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [execution](<https://devfeed.tech/topics/execution.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [distributed-consensus](<https://devfeed.tech/tags/distributed-consensus.md>), [execution](<https://devfeed.tech/tags/execution.md>), [latency](<https://devfeed.tech/tags/latency.md>), [livediscussion](<https://devfeed.tech/tags/livediscussion.md>), [network](<https://devfeed.tech/tags/network.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [paxos](<https://devfeed.tech/tags/paxos.md>), [raft](<https://devfeed.tech/tags/raft.md>), [replication](<https://devfeed.tech/tags/replication.md>)

### AI overview

This paper review examines Jetpack, an add-on framework for existing leader-based consensus protocols. Jetpack runs a 1-RTT fast path alongside the original 2-RTT path, potentially reducing WAN commit latency, but its dual-log design duplicates network and replica processing and separates fast commitment from state-machine execution ordering.

### Source excerpt

Aleksey and I are back to reading papers live. This paper, Jetpack(OSDI '26), attempts building a universal 1-RTT fast-path framework that bolts onto existing leader-based consensus protocols with minimal modification. Why would we want this? Classic consensus protocols like Raft, Paxos, or Zab require two round-trip times (2 RTT) to commit a command: one RTT from client to leader, and another to replicate across followers. The extra RTT matters a lot for WAN deployments, so fast-path protocols (such as Fast Paxos, EPaxos, or SwiftPaxos) reduce this to 1 RTT by bypassing leader serialization, but unfortunately they tightly couple the fast path to the core protocol design. Production systems cannot easily swap out their battle-tested bespoke consensus engines, but if there was an add on that helped with latency especially in WAN deployments, that would be useful. The good news is that Jetpack is truly an add-on portable deal. It provides a shim layer that runs two execution paths in parallel: a 1-RTT fast path and the original 2-RTT consensus path. When a client issues a command, it broadcasts the request concurrently to both paths. The fast path checks for key conflicts, and if none exist and a supermajority quorum ($\sim 3/4$ of nodes) issues a promise, this enables the command to fast-commit in 1 RTT. To guarantee agreement, original path proposers promise not to propose conflicting commands ahead of fast-committed ones. The bad news is that this design gets wasteful due to keeping two distinct logs (the fast-path log and the original-path log). The original consensus engine runs its full replication cycle in the background, ignoring the fast path replication of commands (because it is completely oblivious to the fast path replication in the name of bolt-on portability). So these commands travel in the network twice, and replicas process commands twice, introducing redundant work and extra CPU/network overhead. This dual-log architecture also creates a bigger gap

## Metastability as a failed conditional discharge of rely-guarantee composition

DevFeed: [Metastability as a failed conditional discharge of rely-guarantee composition](<https://devfeed.tech/articles/metastability-as-a-failed-conditional-discharge-of-rely-guarantee-composition-41859.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/09/metastability-as-failed-conditional.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-09-03T01:03:24Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [systems](<https://devfeed.tech/topics/systems.md>), [retry](<https://devfeed.tech/topics/retry.md>), [Server](<https://devfeed.tech/topics/server.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [latency](<https://devfeed.tech/tags/latency.md>), [metastability](<https://devfeed.tech/tags/metastability.md>), [retries](<https://devfeed.tech/tags/retries.md>), [server](<https://devfeed.tech/tags/server.md>), [systems](<https://devfeed.tech/tags/systems.md>), [tla](<https://devfeed.tech/tags/tla.md>)

### AI overview

This post models metastability in a retry storm using TLA+ and a retrier-server composition. It argues that a trigger can displace a system outside the rely-guarantee conditions of its components, after which duplicate retries add queue load and waste capacity. The model uses server capacity, fresh arrivals, retry timeouts, and latency thresholds to study the resulting failure behavior.

### Source excerpt

Last week I wrote about modular verification of systems through open TLA+ specs and rely-guarantee discharge. In this post, I apply the same approach to study the metastability mechanics of a retry storm. Through this modeling I show that when the system is metastable, it is due to some trigger/shock that displaced the system outside the rely-guarantee discharge conditions of its components. The model I use the retrier-server example from the "Characterizing Metastable Faults and Failures" paper and model it in TLA+ as a composition of a retrier and a server component. The shared interface between the two components consist of the following variables: qf: fresh work queued at the server qd: duplicate (retry) work queued at the server done: the count of fresh requests the server completed this round, which the retrier reads and clears turn: a flag forcing alternation between the retrier and server steps The retrier has one private variable, p, which denotes the pending fresh requests: the requests sent and not yet acked. A retry is a duplicate of a request already counted in p, so sending one does not grow p. The server has no private state, and does not know about p. The constants in the specs parametrize the most important system characteristics: S=3 is the server capacity to process units per round AMax=2 is the max arrivals of fresh requests per round; retries arrive on top of this T=2 denotes retry timeout in rounds. Since AMax<S, client demand stays below server capacity, so under normal conditions the server coasts. Whatever goes wrong will be due to a trigger/shock. Recall that metastability is a three act play: a trigger creates a backlog, the trigger goes away, but the system fails to recover. Since we only study the last act here, I model the trigger by starting the system in an already displaced state: Q0 requests are already queued at the server (qf=Q0) and, none being answered yet, all still open on the retrier's ledger (p=Q0). How does this initial sho

## Why the Author Thinks LLMs Still Struggle with Writing

DevFeed: [Why the Author Thinks LLMs Still Struggle with Writing](<https://devfeed.tech/articles/the-safest-job-from-ai-may-be-writing-41854.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/08/the-safest-job-from-ai-may-be-writing.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-08-31T18:01:30Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Code](<https://devfeed.tech/topics/code.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-writing](<https://devfeed.tech/tags/ai-writing.md>), [code](<https://devfeed.tech/tags/code.md>), [llm](<https://devfeed.tech/tags/llm.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The author argues that LLMs have become effective at generating code but still produce prose that feels formulaic, shallow, and inauthentic. The article attributes this gap partly to writing's subjective and difficult-to-verify nature, and argues that decent writers may remain relatively safe from AI disruption for now.

### Source excerpt

Today, tech folk are scrambling to change their workflows to meet newly inflated 5X productivity quotas, while getting pummeled under the cognitive debt of agent-generated code. With every new model release, the gap is widening and humans are becoming more of a bottleneck in the loop, approaching closer to obsolescence as "coders". While the programmer's job description is getting completely refactored, writing remains surprisingly unaffected. LLMs have gotten very good at generating code, but I am appalled at the absolute shit they spew as prose. They always follow the same robotic cadence and cliches, and sprinkle the same tired vocabulary all around. They take my broken yet soulful writing and transform it into a plastic soulless word slop in the name of improving prose. Their writing communicates no actual understanding and insight. I think we are all developing a visceral ick reaction to AI writing. It is trapped in the uncanny valley, and it may be stuck there for a long time. I am increasingly convinced LLMs will not threaten decent writers anytime soon. My prediction rests on the three observations below. Tell me where my logic does not hold up. The plateau on prose The stuck-in-slop state of LLM writing is not from lack of trying. AI labs already tried hard on improving prose and hit a wall. LLM giants would have loved to ship better writing capability to conquer marketing, copywriting, and publishing at zero marginal cost. Look at image, voice, and heck video models. They got good quickly, because they can be scaled with more parameters and compute. Compared to their rapid progress, text models plateaued hard on expression, depth, and authenticity. I think it is wicked hard to bride the final 20% (also applies for image, voice, video models). Writing is a wicked problem In systems theory, a wicked problem is a problem that lacks a definitive formulation, a clear stopping rule, and an objectively correct solution. Writing is the ultimate wicked problem, bec

## Composition and Modular Verification of TLA+ specs

DevFeed: [Composition and Modular Verification of TLA+ specs](<https://devfeed.tech/articles/composition-and-modular-verification-of-tla-specs-41852.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/08/composition-and-modular-verification-of.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-08-27T01:03:04Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [execution](<https://devfeed.tech/topics/execution.md>), [test](<https://devfeed.tech/topics/test.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [automated-reasoning](<https://devfeed.tech/tags/automated-reasoning.md>), [component](<https://devfeed.tech/tags/component.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [llms](<https://devfeed.tech/tags/llms.md>), [logical](<https://devfeed.tech/tags/logical.md>), [system](<https://devfeed.tech/tags/system.md>), [tla](<https://devfeed.tech/tags/tla.md>)

### AI overview

An opinionated exploration of modular verification for TLA+ specifications. It explains how composing specifications over shared state can over-constrain systems, and argues that open specifications, LLMs, and TLAPS may make modular verification more practical.

### Source excerpt

Preamble. This post came slowly, simmering over months really. So there is some stream of consciousness in here, and a lot of deliberating in public. The post is me learning modular verification and talking myself into it at the same time. Even pep-talking myself, because this is genuinely hard, and the field's standard advice is to avoid modular verification. But the advice is due for revision: LLMs plus TLAPS are quietly changing the economics that made monolithic spec the rational default. The compositionality problemTLA+ is compositional in the abstract sense... In the astral plane, a program execution is an infinite sequence of states, each state giving a value to every variable in an imagined universal state space. A spec is a predicate (yes/no test) on executions, which denotes a set of allowed executions. In this setup, the steps that change variables in other specs look like stuttering to yours. And that enables us to denote composition as a beautiful purely logical conjunction, Spec1 /\ Spec2. The problem is, this is too pure. When you try to model check a conjunction of two specs, your astral travel gets grounded. Since TLC only accepts specs in the normal form Init /\ [][Next]_vars, you need to manually expand the conjunction of two boxed formulas as: [][N1]_v1 /\ [][N2]_v2 = []((N1 \/ UNCHANGED v1) /\ (N2 \/ UNCHANGED v2)) Expanding this gives us joint steps for N1/\N2, solo steps for each side, and both side stutter steps (which can be omitted vacuously). However, shared read/write variables between N1 and N2 cause problems (which we have ignored conveniently in the first paragraph, and now it is time to face them). Suppose a producer and a consumer share a channel. The naive producer spec Init /\ [][PNext]_<<chan, produced>> says: if chan changes, it was one of my actions. If you conjoin that with a consumer that also writes chan, you have specified a system where the consumer can never take a value. Conjunction of closed specs over shared state leads

## Thoughts on LLMs

DevFeed: [Thoughts on LLMs](<https://devfeed.tech/articles/thoughts-on-llms-41855.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/08/thoughts-on-llms.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-08-23T18:38:54Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [ai](<https://devfeed.tech/tags/ai.md>), [llms](<https://devfeed.tech/tags/llms.md>)

### AI overview

An index of the author's writing about LLMs, alongside a broader assessment that LLMs produce mediocre output quickly and are useful for handling mundane parts of projects.

### Source excerpt

I am a distributed systems researcher. I mostly read and write about distributed systems and lightweight formal methods. But as my blog definition says, the blog is about "distributed systems broadly defined and other curiosities". The last two years, LLMs were unavoidably the biggest part of those curiosities. However, I was still surprised how much I had written about them, when I went looking for a line I remembered coining. Something like, "LLMs are good at mediocrity, but really fast". I couldn't find the line, but instead I found a pile of my takes on LLMs scattered across the blog, and I figured it was worth collecting them into an index. So here it is, enjoy! I also threw in my overall take on LLMs that has stayed constant through their four years of reign so far. Hot takes on LLMs Our Collective Bike Shed Moment (June 26) Are We Becoming Architects or Butlers to LLMs? (Feb 26) How LLMs may affect academic writing (Feb 26) Agentic AI and The Mythical Agent-Month (Jan 26) The Agentic Self: Parallels Between AI and Self-Improvement (Jan 26) Too Close to Our Own Image? (Jan 26) Rethinking the University in the Age of AI (Jan 26) Welcome to Town Al-Gasr (Jan 26) The Invisible Curriculum of Research (Oct 25) -- mostly about AI, trust me Academic chat: On PhD (Oct 25) -- follow-up to the above What I'd do as a College Freshman in 2025 (Apr 25) Hot damn, 11 posts deep... Apparently I am an AI thought leader now by accident. Looking at the dates, I was clearly most obsessed with LLMs in January 2026. There is no surprise there, since agentic tools and models turned a real corner that Thanksgiving of 2025. What has stayed constant over the years, however, even as the models themselves got much better, is my verdict on them. The phrase I had been hunting for turned out to be: "LLMs excel at high-throughput mediocrity". LLM output looks excellent when you are not the expert in the room. But on a topic you actually know, you would evaluate the output only as a notch above

## Specula: Scaling formal specifications for autonomous model checking of system code

DevFeed: [Specula: Scaling formal specifications for autonomous model checking of system code](<https://devfeed.tech/articles/specula-scaling-formal-specifications-for-autonomous-model-checking-of-system-code-41853.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/08/specula-scaling-formal-specifications.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-08-12T21:33:44Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [bug](<https://devfeed.tech/topics/bug.md>), [Code](<https://devfeed.tech/topics/code.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Software](<https://devfeed.tech/topics/software.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Network](<https://devfeed.tech/topics/network.md>), [C](<https://devfeed.tech/topics/c.md>), [Erlang](<https://devfeed.tech/topics/erlang.md>), [MongoDB](<https://devfeed.tech/topics/mongodb.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [bug](<https://devfeed.tech/tags/bug.md>), [code](<https://devfeed.tech/tags/code.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [developers](<https://devfeed.tech/tags/developers.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [erlang](<https://devfeed.tech/tags/erlang.md>), [etcd](<https://devfeed.tech/tags/etcd.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [mongodb](<https://devfeed.tech/tags/mongodb.md>), [network](<https://devfeed.tech/tags/network.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [paper-review](<https://devfeed.tech/tags/paper-review.md>), [rabbitmq](<https://devfeed.tech/tags/rabbitmq.md>), [rust](<https://devfeed.tech/tags/rust.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [tla](<https://devfeed.tech/tags/tla.md>)

### AI overview

An opinionated analysis of Specula, an agentic system that automatically derives TLA+ specifications from software, validates them against code, model-checks for concurrency bugs, and generates integration tests. The article discusses reported results across 48 open-source distributed and concurrent systems, including 249 bugs found, while also raising unresolved questions about the approach.

### Source excerpt

Specula is an agentic system that automates the process of software bug finding through authoring and model-checking a spec for the code. It derives TLA+ specifications automatically from the code, checks code-spec conformance through trace validation, model checks the spec to find concurrency bugs, and reproduces the bug at the code layer by writing integration tests with precise timing. I remember reading the Daikon paper "Quickly detecting relevant program invariants" in 2000 and getting impressed by it, and here we are after 26 years, solving the end-to-end problem much better than I ever thought would be possible in a push-button manner in the year of our lord 2026. But somehow, I am still somewhat unsatisfied with the paper. This may be me being hypercritical and trying to get more out of the paper by arguing with it. So bear with me until I resolve (or learn to accept) these problems over time. I know many of the authors of the Specula work, and respect them, and I know they won't take my critiques about the larger problem in a wrong way... I am trying to make sense of the terrain myself. So, let's look at what Specula gets right, its major contributions, and then dive into my unresolved questions and existential thinking about the terrain. Why is Specula an Impressive Achievement Specula is run on "slices of" 48 complex open-source distributed and concurrent systems including MongoDB, Microsoft's SONiC network OS, GCC's libgomp, Etcd, and RabbitMQ's ra. It found 249 bugs, 207 of them new. The 48 systems span 7 languages, from C to Erlang to Rust. This is very impressive, and it earns the "scaling" claim in the title of the paper. Hand-crafting TLA+ specifications may take weeks (especially for unfamiliar code bases), and Specula completes end-to-end checks in 1.4 to 9.8 hours at a median token cost of 57 dollars per system. Did I mention this is all push-button? Developers just review the end results. They may not even have to look at the TLA+ specs, and the

## Towards Designing an Execution Control System with Metastability Resilience

DevFeed: [Towards Designing an Execution Control System with Metastability Resilience](<https://devfeed.tech/articles/towards-designing-an-execution-control-system-with-metastability-resilience-41856.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/08/towards-designing-execution-control.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-08-02T06:46:15Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [execution](<https://devfeed.tech/topics/execution.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>), [Database](<https://devfeed.tech/topics/database.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [retry](<https://devfeed.tech/topics/retry.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Network](<https://devfeed.tech/topics/network.md>)

Tags: [databases](<https://devfeed.tech/tags/databases.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [latency](<https://devfeed.tech/tags/latency.md>), [metastability](<https://devfeed.tech/tags/metastability.md>), [my-paper](<https://devfeed.tech/tags/my-paper.md>), [network](<https://devfeed.tech/tags/network.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [retries](<https://devfeed.tech/tags/retries.md>), [retry](<https://devfeed.tech/tags/retry.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article discusses designing a metastability-tolerant execution control system for databases. It explains how mixed workloads, overload, delayed signals, retries, and workload misclassification can create self-sustaining degraded states in cloud database systems.

### Source excerpt

This week, I presented this paper at ICCCN'26. This is joint work with Aleksey Charapko (University of New Hampshire) and my MongoDB colleagues Matt Broadstone, Daniel Gomez Ferro, and Akshat Vig. The paper investigates how to build a metastability tolerant execution control system (ECS) for a database. Why? Modern databases are complex networked systems serving mixed workloads: short queries (that want an answer in milliseconds) sitting next to analytics jobs (that want the CPU for multiple seconds). The arrival rate of requests is effectively unbounded, but of course, the server's resources are not. And, unfortunately, elastic scaling does not save you here. Scaling takes minutes, whereas, overload takes seconds. Admission control tries to guard the front door (more on this later), but the component that mediates contention once requests reach the backend is the execution control system (ECS). Unlike a closed system OS scheduler, which strives for fairness and completeness by giving runtime for every thread, faced with an open environment the ECS can only afford to protect short latency-sensitive queries and shed the excess, pushing the burden of waiting back across the network to the clients. This doesn't mean that long tasks are starved, as they can retry until capacity permits execution. However, shedding load across a network is risky business. Clients do not see the server slow down, instead they time out and retry aggressively. Moreover, workloads are also unpredictable. A query that looks short may hang on a lock or blow up into a scan. The combination of delayed signals, retries, and misclassification makes the cloud databases a fertile ground for failures. The specific failure we worry about here is metastability: the system gets pushed into a degraded state, and the degraded state sustains itself even after the original trigger is removed. The mechanisms you build for resilience (the retries and the queues) turn into positive feedback loops after a trigg

## Aurora DSQL: Scalable, Multi-Region OLTP

DevFeed: [Aurora DSQL: Scalable, Multi-Region OLTP](<https://devfeed.tech/articles/aurora-dsql-scalable-multi-region-oltp-41849.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/07/aurora-dsql-scalable-multi-region-oltp.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-07-24T00:15:59Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [DSQL](<https://devfeed.tech/topics/dsql.md>), [Database](<https://devfeed.tech/topics/database.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>), [stateless](<https://devfeed.tech/topics/stateless.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [aws](<https://devfeed.tech/tags/aws.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [distributed-transactions](<https://devfeed.tech/tags/distributed-transactions.md>), [distsql](<https://devfeed.tech/tags/distsql.md>), [dsql](<https://devfeed.tech/tags/dsql.md>), [mvcc](<https://devfeed.tech/tags/mvcc.md>), [paper-review](<https://devfeed.tech/tags/paper-review.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [replication](<https://devfeed.tech/tags/replication.md>), [routing](<https://devfeed.tech/tags/routing.md>), [stateless](<https://devfeed.tech/tags/stateless.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

An analysis of Aurora DSQL's architecture, which decomposes a traditional monolithic database into independently scalable services for query processing, storage, conflict resolution, replication, and routing. It also examines synchronized clocks, MVCC, snapshot isolation, and optimistic concurrency control.

### Source excerpt

The Aurora DSQL paper finally dropped. Reading it yesterday was an interesting experience, because I spent two years (2022-23) working with the AWS team that designed and built Aurora DSQL. Since I have been very familiar with the architecture, the paper's overview description of the system didn't excite me much. And if I am being honest, reading the paper also felt a bit dry, most likely because I am not doing the usual extra thinking to explore/understand the ideas in the paper. But taking a step back today, and leaving my subjective experience aside, I will try to elaborate on how the DSQL architecture is actually built on a set of aggressive and opinionated engineering bets. If I had to explain this architecture in a single sentence (just as I used to do for other teams at AWS) it would be this: We took a traditional monolithic database and blew out every single component into an independent, horizontally scalable service. Exploding the Monolith DSQL divides the database into the following specialized services: Query Processors (QP): Stateless virtual machines that run a custom PostgreSQL engine to parse queries and buffer writes locally. Storage Nodes: Sharded nodes that hold the data and use multiversion concurrency control (MVCC) to serve historical data to QP instantly. Adjudicators: The conflict-resolution layer that checks if a transaction handed of to them by QP is safe to commit. Journals: A highly available replication log that durably saves transactions across zones or regions. (Good for short term durability before this reaches the storage nodes. See my MemoryDB review.) Crossbars: The routing layer that reads the updates from the Journals and sends changes to the right Storage Nodes. The Big Architectural Bets in DSQL Design Well, in addition to fully committing to the disaggregation principle, here are the other big bets in DSQL design. The Synchronized Clock Bet: To get reads without coordination, DSQL relies entirely on highly synchronized physica

## Characterizing Metastable Faults and Failures

DevFeed: [Characterizing Metastable Faults and Failures](<https://devfeed.tech/articles/characterizing-metastable-faults-and-failures-41850.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/07/characterizing-metastable-faults-and.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-07-22T06:21:52Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [systems](<https://devfeed.tech/topics/systems.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [metastability](<https://devfeed.tech/tags/metastability.md>), [outages](<https://devfeed.tech/tags/outages.md>), [paper-review](<https://devfeed.tech/tags/paper-review.md>), [queues](<https://devfeed.tech/tags/queues.md>), [retries](<https://devfeed.tech/tags/retries.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [stabilization](<https://devfeed.tech/tags/stabilization.md>)

### AI overview

A review of a June 2026 paper that develops an analytical account of metastable faults and failures in distributed systems. The paper connects these failures to composition among self-stabilizing systems and scheduling, while the review questions its treatment of prior work and its use of local pairwise reasoning.

### Source excerpt

Metastability has been studied in previous work as a self-sustaining degradation in goodput that persists even after the trigger is gone. The degraded state loiters on entirely due to the system's own internal feedback loops (retries, queues), and there is no simple reset button to press in distributed systems. So this is not a rare exotic problem. Since production systems would have already been hardened to handle the obvious failures, what remains is these hard-to-detect emergent failures. The "Metastable Failures in the Wild" paper (OSDI'22) reports 22 incidents across 11 organizations. Four of the 15 major AWS outages in a decade were metastable failures, with durations ranging from 1.5 to 73 hours. This paper (June 2026) argues that the systems community has treated metastability phenomenologically, which led people to chase symptoms rather than causes. The paper sets out to give the first analytical causal account of these failures. This framing leads to two connections I found delightful. The first casts a metastable failure as a sin of composition among self-stabilizing systems. The second ties the healing mechanism to scheduling. Since I have worked on self-stabilizing systems for a long time (between 1998-2010), and thought hard about how they compose, these two connections really excite me. I do have some reservations, though, which I will get to in my review. The paper overlooks prior work on the composition of stabilizing systems. It also pulls a bit of a sleight-of-hand in its formalization to argue that the metastable fault tolerance (MFT) design can be done via local pairwise reasoning between components. I don't buy that as I explain below. These reservations do not dampen how much I enjoyed this paper. This is an idea paper, and it has been a while since I saw one of these in distributed systems. Moreover, the author list includes two of my all-time favorite distributed systems researchers: Robbert Van Renesse and Lorenzo Alvisi. So let's dive in.

## Why Society Is Underestimating the Significance of LLMs

DevFeed: [Why Society Is Underestimating the Significance of LLMs](<https://devfeed.tech/articles/our-collective-bike-shed-moment-41845.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/06/our-collective-bike-shed-moment.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-06-20T03:51:13Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [bias](<https://devfeed.tech/tags/bias.md>), [llms](<https://devfeed.tech/tags/llms.md>), [opinions](<https://devfeed.tech/tags/opinions.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>)

### AI overview

The essay argues that people are devoting disproportionate attention to minor debates about LLMs while failing to engage deeply with their broader significance. It attributes this response to normalcy bias and the tendency to treat major issues as somebody else's problem.

### Source excerpt

In 1957, Parkinson postulated his "Law of Triviality" using a fictitious committee reviewing plans for a nuclear power plant. The reactor design gets 10 minutes because nobody understands it, so nobody argues. The bike shed gets 45 minutes because everyone has opinions about the paint color. I feel like we are living this committee meeting at scale every day. LLMs are already better engineers than most of us. They are better at formal methods, and better at reasoning under pressure than most people. They run at incredible speed and don't get tired. They improve continuously. But, some people keep moving the goalposts on LLMs. First they said LLMs couldn't code. Then they said they hallucinated too much. All of these barriers fell, but some people are still scoffing at these systems. What chutzpah! If aliens landed in Central Park tomorrow, I don't think the reaction would be that different. With AI, an alien form of intelligence has already arrived in our laps, and we gave it a collective shrug and kept scrolling. Psychologists call this the normalcy bias. We tend to assume things will continue roughly as they have, even when confronted with something that requires revising our picture of the future. Douglas Adams introduces an adjacent phenomena, called the Somebody Else's Problem (SEP) field. The SEP field does not try to make something invisible directly, rather it makes your brain classify it as somebody else's problem, so it gets actively skipped. An alien spacecraft hovers over a crowded park unnoticed, because everyone has silently agreed it's someone else's problem. The individual adaptation strategy makes sense of course. Learn the tools, and stay ahead of the curve to save your own ship. Why not? Stay afloat the next couple years. But what about the coming decades? I am not saying everyone should engage with everything. I know about the circles of control, influence, and concern. But, unfortunately, even the people who should be debating this (technologist

## Our MongoDB TLA+ Workshop

DevFeed: [Our MongoDB TLA+ Workshop](<https://devfeed.tech/articles/our-mongodb-tla-workshop-41847.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/06/our-mongodb-tla-workshop.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-06-13T13:23:23Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Formal methods](<https://devfeed.tech/topics/formal-methods.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Prompt Engineering](<https://devfeed.tech/topics/prompt-engineering.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [prompting](<https://devfeed.tech/tags/prompting.md>), [tla](<https://devfeed.tech/tags/tla.md>)

### AI overview

A MongoDB research team describes a second TLA+ workshop that used AI and Claude Code to reduce the time needed to begin formal modeling. Attendees modeled parts of current work projects, and feedback indicated that the exercises exposed liveness issues and design ambiguities.

### Source excerpt

Shortly after I joined MongoDB research, we ran a TLA+ workshop. It was a two-day ordeal. We had a 1.5 days of instruction on TLA+ and syntax, after which we tried to help people get started with modeling. People liked learning about TLA+ on the first day, but except for a person or two, we didn't get anyone onboarded with TLA+ modeling. It was too much to offload on people and ask them to level up in a short time frame. Well, two years after that first workshop, on May 11th, 2026, we ran a second edition of this workshop with one very big difference. What is that big difference, you ask? AI! AI makes formal methods not only necessary, but also more feasible and easier! Jesse, Will, and I planned this workshop to be aggressively short. We provide under two hours of instruction, then everyone starts modeling hands-on. We act as TAs and help people as they go. The AI takes care of the syntax problem for TLA+, and also helps with modeling. We just need to teach people enough to read and make sense of a model, and Claude Code would take care of the rest. You have a problem? Ask Claude. Still stuck? Ask us. Take away: Green Path to 100 true fans Ok, I will cut to the chase. The workshop was a great success! My biggest takeaway from it is this: I finally see a green path to 100 true fans. We had an order of magnitude greater conversion rate compared to the first workshop. Almost all of the attendees got started with modeling, and almost all of those modeled a part of an actual work project they are currently on. As I've written before, with AI tools it is easy to be "technically fearless." People who had been heavy Claude users did a great job prompting and interacting with Claude, and hit the ground running. Some people were still hesitant to take the first step, but when one of us sat down with them, they quickly got over that initial friction and were off and modeling within minutes. Workshop feedback report We asked attendees to fill out a feedback survey afterward, a

## Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools

DevFeed: [Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools](<https://devfeed.tech/articles/writing-code-vs-shipping-code-productivity-effects-across-generations-of-ai-coding-tools-41848.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/06/writing-code-vs-shipping-code.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-06-09T04:08:26Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [developer-productivity](<https://devfeed.tech/topics/developer-productivity.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Grafana Cloud Metrics](<https://devfeed.tech/topics/grafana-cloud-metrics.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [cursor](<https://devfeed.tech/topics/cursor.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [async](<https://devfeed.tech/topics/async.md>), [autocomplete](<https://devfeed.tech/topics/autocomplete.md>), [Microsoft](<https://devfeed.tech/topics/microsoft.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [autocomplete](<https://devfeed.tech/tags/autocomplete.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code-productivity](<https://devfeed.tech/tags/code-productivity.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [github](<https://devfeed.tech/tags/github.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [software](<https://devfeed.tech/tags/software.md>), [telemetry](<https://devfeed.tech/tags/telemetry.md>)

### AI overview

This article examines research from MIT and Wharton on the productivity effects of AI coding tools. It argues that gains in code-generation and task-level activity diminish as work moves toward production and shipping, comparing autocomplete, synchronous coding agents, and autonomous asynchronous agents.

### Source excerpt

The transformative power of LLMs in coding has been irrefutable, and it feels like we are living through a magical computing renaissance. On the socials, we hear impressive numbers of lines of code generated, features delivered, and bugs fixed. But, the macroeconomic indicators seem to be still lagging. Heck, if you talk with an engineering manager, you find that their product shipping dates haven't miraculously compressed by a factor of five, either. This paper just landed 10 days ago. It is from MIT and Wharton by Mert Demirer, Leon Musolff, and Liyuan Yang. Their study attempts to provide a structured economic model for evaluating actual productivity obtained from AI coding tools. By pairing confidential Microsoft telemetry with the public footprints of over 100,000 GitHub developers (tracking everything from open-source utilities to web app repositories), the authors show significant systemic friction downstream of AI code generation. Of course, I do my usual skeptical critic of the paper. In this case, this is especially heightened because these are economists peeking into the messy non-linear world of software engineering and trying to impose a "production hierarchy" abstraction onto it. But if we reconsider their analysis from a different perspective, it becomes possible to translate their complex production functions into Amdahl's Law terms, and then we can start doing our own evaluations and draw our own conclusions as I discuss below. The Monotonic Decay The core of the paper rests on this monotonic decay argument. The sheer task-level velocity gains we see from AI coding tools start to bleed out as they move up the production hierarchy. The authors break down AI tool adoption into three distinct generational tiers: Autocomplete (intelligent text prediction), Synchronous (Sync) Agents (interactive, real-time code modifiers like Claude Code or Cursor), Asynchronous (Async) Agents (autonomous async agents). When we look at the task-level velocity of these to

## A Case for Simulation-Driven Resilience in Agentic Data Systems

DevFeed: [A Case for Simulation-Driven Resilience in Agentic Data Systems](<https://devfeed.tech/articles/a-case-for-simulation-driven-resilience-in-agentic-data-systems-41843.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/06/a-case-for-simulation-driven-resilience.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-06-08T03:40:45Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>), [systems](<https://devfeed.tech/topics/systems.md>), [AI Bots](<https://devfeed.tech/topics/ai-bots.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [data-systems](<https://devfeed.tech/tags/data-systems.md>), [databases](<https://devfeed.tech/tags/databases.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [metastability](<https://devfeed.tech/tags/metastability.md>), [queues](<https://devfeed.tech/tags/queues.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [retries](<https://devfeed.tech/tags/retries.md>), [systems](<https://devfeed.tech/tags/systems.md>), [work](<https://devfeed.tech/tags/work.md>)

### AI overview

This article explains how metastability can arise when retries, queues, timeouts, and load shedding amplify overload instead of containing it. It argues that AI agents, as increasingly important clients of data systems, intensify these feedback loops and makes the case for simulation-driven approaches to building resilient distributed systems.

### Source excerpt

As I mentioned in my previous post, I traveled to San Jose at the end of May for the ACM CAIS conference. On Day 0, I gave a very short talk at the Supporting our AI Overlords (SAO) workshop. This post is the promised summary of our paper, "A Case for Simulation-Driven Resilience in Agentic Data Systems", joint work with Aleksey Charapko (University of New Hampshire) and Akshat Vig (MongoDB). Metastability is critical for building the next generation of distributed systems Our story starts with metastability. Metastability is the failure mode where the mechanisms built to protect the system (retries, queues, timeouts, load shedding) turn into amplifiers. Even after the trigger that caused the overload goes away, the system stays behind, churning through busy work, perpetually trying to catch up with the remnants of failed and behind-schedule tasks. It's a bit like missing some foundational math in high school. You spend so long backfilling the old gaps that you never keep up with the new material piling on top, so you stay permanently behind. The catching up work is what keeps you behind, which requires catching up work later, which keeps you behind. (This is presumably why I'm not a rich machine learning scientist today at Deep Mind.) Avoiding and tolerating metastable failures is critical to building the next generation of reliable distributed systems. Aleksey's Metastable Failures in the Wild study (OSDI'22) cataloged these failures from real production incidents. They matter so much because they are the hard faults that remain. We have largely learned to deal with the straightforward ones (crashes, corruptions, dropped packets), which leaves emergent performance failures as the final boss. Metastable failures are responsible for a disproportionate share of critical cloud unavailability incidents, with no single broken part to point at and no obvious way to fix/reset them when they emerge. The cloud economics make the problem worse. Providers and operators have e

## ACM CAIS: Conference on AI and Agentic Systems

DevFeed: [ACM CAIS: Conference on AI and Agentic Systems](<https://devfeed.tech/articles/acm-cais-conference-on-ai-and-agentic-systems-41844.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/06/acm-cais-conference-on-ai-and-agentic.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-06-02T17:29:07Z

Content type: opinion

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [AI Development](<https://devfeed.tech/topics/ai-development.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [data](<https://devfeed.tech/topics/data.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>)

Tags: [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [conference](<https://devfeed.tech/tags/conference.md>), [data-systems](<https://devfeed.tech/tags/data-systems.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [developer](<https://devfeed.tech/tags/developer.md>), [development](<https://devfeed.tech/tags/development.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [systems](<https://devfeed.tech/tags/systems.md>), [trip-report](<https://devfeed.tech/tags/trip-report.md>)

### AI overview

The author reflects on the ACM CAIS conference on AI and agentic systems, describing its research as exploratory and often anecdotal. They argue that the conference would benefit from a narrower focus on data systems and infrastructure for AI, and discuss engagement, short presentation formats, and lessons from an Agent Skills workshop.

### Source excerpt

Last week, I traveled to San Jose to attend the ACM CAIS conference. On Day 0, I gave a short talk at the Supporting our AI Overlords (SAO) workshop. And yes, I promise to write a summary of our paper, "A Case for Simulation-Driven Resilience in Agent-First Data Systems" soon! To start with an overall impression of the conference: much of the work presented felt exploratory and anecdotal. Since the compound AI space is still so new, many work seemed to share on-the-ground best practices that worked for them rather than principled results. Some talks really leaned into the "agent, act like a senior engineer and don't make mistakes" vibe. This was especially apparent in the "Agent Skills Workshop". I am not saying this is a bad thing, I learned some valuable lessons from that workshop, which I'll share below. CAIS defines the conference's scope broadly as "research on compound AI architectures, optimization, and deployment". Unfortunately, this broadness seemed to work against the main track. Attendance at the primary conference talks was low, and it often felt like attendees were there solely to present their own work rather than engage with others, likely because the subject matter was spread too thin. In contrast, the workshops were highly focused, which led to much better engagement and active listening from the audience. Moving forward, I think CAIS would benefit greatly from narrowing its focus, maybe specifically focusing more on data systems and infrastructure in support of AI. On that note, what happened to our collective attention span? CAIS limited paper presentations to 7 minutes with just 2 minutes for questions. This year, SIGMOD also shifted to 9-minute talks. Our own paper, "LeaseGuard: Raft Leases Done Right!", got a mere 9 minutes in the spotlight after Jesse traveled all the way to Bangalore to present it. I've even heard that USENIX Security is down to 3-minute talks now. Should we maybe consider slowing down? After all, isn't attention all we need

[Next page](<https://devfeed.tech/sources/metadata.md?cursor=WyIyMDI2LTA2LTAyVDE3OjI5OjA3KzAwOjAwIiwgIjE2OGViNTU2LTVkMjctNDYxNy1hMDNlLTkzNzU3NTE2OGVjOSJd>)