# Newsletter feed for Hillel Wayne's Newsletter

Hi, I'm Hillel. This is the newsletter version of my website. I post all website updates here. I also post weekly content just for the newsletter, on topics like Formal Methods Software History and Culture Fringetech and exotic tooling The philosophy and theory of software engineering You can see the archive of all public essays here.

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

## My Least Favorite Example in Software Engineering

DevFeed: [My Least Favorite Example in Software Engineering](<https://devfeed.tech/articles/my-least-favorite-example-in-software-engineering-144363.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/my-least-favorite-example-in-software-engineering/>)

Author: Hillel Wayne

Published: 2026-11-19T15:40:32Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [example](<https://devfeed.tech/tags/example.md>), [property-based-testing](<https://devfeed.tech/tags/property-based-testing.md>), [reverse](<https://devfeed.tech/tags/reverse.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The familiar property-based testing example--generating a random list and checking that reversing it twice restores the list--shows what PBT is, but the author says it poorly teaches why the technique matters in real software. Examples should be understandable, representative of real use, and help learners find related cases. The author suggests the example spread because it is simple and language-agnostic, and because John Hughes's QuickCheck paper used it. Earlier authors, including Zohar Manna, Boyer and Moore, and Richard Bird and Philip Wadler, had used double reversal to illustrate proofs; Hughes used it as a property to test. The same example can suit one context and fail another, and double reversal was useful in Hughes's work on list representations. The critique is about teaching usefulness, not blame.

### Source excerpt

I'm doing a lightning talk at Brooklyn Web Workers on 11/30! If you're in the area, come check it out. If you're not in the area (like 99.90% of the world), you can just read this newsletter instead. As you probably know, I am obsessed with examples. Really, really, really obsessed with examples. The best examples should at least: Be simple enough to understand Clearly showcase the topic under discussion Actually correspond to how the topic manifests in the real world Give some rough idea on how to find other examples in the same vein Basically, the example needs to both help the student understand the topic and also why the topic matters. If not to them, at least to someone they know. A good example of a good example is demonstrating type safety with option types, which ensure that you always handle nulls in your program. It's intuitive, clear, and simple, and it shows why and how this would be useful in practice. But I'm not here to talk about good examples. I'm here to talk about bad examples Specifically my least favorite example. Property-Based Testing is a testing approach where we generate random inputs to a program and check the outputs all satisfy some property. And like half the PBT introductions online use this same example: test reverse-reverse: l = random_list() reverse(reverse(l)) == l I hate this example because 1) I see it every-freakin'-where, and 2) it fails the "this topic matters" criteria hard. It gives you some idea of what property-based testing is, but doesn't give you any way to relate it to actual real-world testing. I mean, who writes list reversal algorithms for their job?1 And sure, common examples of regular testing like add(1, 2) == 3 are also useless, but 1) regular testing is mundane and you can probably figure out more useful tests from that 2) most people can give you better examples than that! PBT, on the other hand, is quite exotic for most people and they need a lot of guidance on how to go from "learning about the concept of pr

## New Article, Annual LFP Charity Discount

DevFeed: [New Article, Annual LFP Charity Discount](<https://devfeed.tech/articles/new-article-annual-lfp-charity-discount-117176.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/new-article-annual-lfp-charity-discount/>)

Author: Hillel Wayne

Published: 2026-11-03T18:06:44Z

Content type: release

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [deterministic-simulation](<https://devfeed.tech/topics/deterministic-simulation.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [charity](<https://devfeed.tech/tags/charity.md>), [discount](<https://devfeed.tech/tags/discount.md>)

### AI overview

The "Why Antithesis" post compares Deterministic Simulation Testing with Formal Methods, highlighting a tradeoff between input coverage and code fidelity. The author also offers Logic for Programmers as a half-price PDF through the end of the month with coupon `feedchicago2026`; all royalties from that coupon go to the Greater Chicago Food Depository. The discount does not apply to an Amazon version.

### Source excerpt

My first blog post for Antithesis is now up! It's called Why Antithesis and is a 2000 word overview on the relative merits of Deterministic Simulation Testing as compared to Formal Methods (tldr there's an essential tradeoff between input coverage and code fidelity). Check it out! Also: last year I did a charity drive for the Greater Chicago Food Depository. It was successful enough that I want to run it again! From now until the end of the month, you can get Logic for Programmers at half price with the coupon feedchicago2026. All royalties from that coupon will go to the Greater Chicago Food Depository. This is only the pdf for now because I have no idea how to make Amazon coupons yet. Thank you!

## NYC, New Webinar, Differential Testing

DevFeed: [NYC, New Webinar, Differential Testing](<https://devfeed.tech/articles/nyc-new-webinar-differential-testing-95895.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/nyc-new-webinar-differential-testing/>)

Author: Hillel Wayne

Published: 2026-10-22T15:14:05Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Single-page application (SPA)](<https://devfeed.tech/topics/spa.md>)

Tags: [differential-testing](<https://devfeed.tech/tags/differential-testing.md>), [nyc](<https://devfeed.tech/tags/nyc.md>), [property-based-testing](<https://devfeed.tech/tags/property-based-testing.md>), [web-applications](<https://devfeed.tech/tags/web-applications.md>), [webinar](<https://devfeed.tech/tags/webinar.md>)

### AI overview

The author argues that comparing deterministic programs is simple: one differing output for the same input shows a divergence. With nondeterministic programs, a single mismatch may reflect an allowed outcome, so repeated observations still may not establish whether behavior differs. Matching sets of observed outputs may also hide asymmetric outcomes--for example, one program may time out where the other succeeds--and differences in outcome rates can matter, as with a biased coin. The author says correctness depends on what counts as a difference, including potentially performance, and suggests that matching sets of possible values may suffice in many cases, though it remains difficult. The excerpt also announces an Antithesis webinar on property-based testing for web applications, emphasizing state-based system invariants over algebraic laws and roundtrip properties.

### Source excerpt

Been a while! Man, it's so much harder to write essays for a newsletter when I have a full time job writing essays for a company. So three bits of housekeeping first of all: As of last month I now live in NYC! Let me know if you want to get coffee or have me swing by an office or something. I'm back on Twitter. Do not mourn me for I do not deserve it. My first big Antithesis deliverable is coming out next Thursday, and it's a webinar on property-based testing. What's going to make this one interesting is that it's about property testing web applications. I've got this crazy idea that the main way to make randomized testing accessible and useful is to focus on state-based system invariants as opposed to algebraic laws and roundtrip properties. Send it to webdevs you know!1 Anyway, to make this actually a newsletter and not just a bunch of updates, one thing I've been thinking about recently is nondeterministic differential testing. Say we have a python program and we tell a slopinator to convert it to rust. How do we know that it didn't change the program's behavior? For a totally deterministic program, this is straightforward differential testing: feed inputs into both and compare the results. Let's scrap out a quick notation and say that A -> (x, y) represents an execution where we input A, and observe that the original program output x and the new program output y. So A -> (1, 1) means that the programs agree on input A, while B -> (1, 2) means they get different values for input B. The programs are different if we observe a single disagreement, meaning we can increase our relative confidence in our translating by trying an increasing number of inputs. That's the base case, anyway. But this only really works because there's no point in repeating observations on the same input. If the program is nondeterministic, we can get situations like this: A -> (200 OK, 408 request timeout) A -> (200, 200) Are the program different? We can't be sure! If the original system al

## What TLA+ can and can't check

DevFeed: [What TLA+ can and can't check](<https://devfeed.tech/articles/what-tla-can-and-can-t-check-62471.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/what-tla-can-and-cant-check/>)

Author: Hillel Wayne

Published: 2026-09-30T13:27:03Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [AutoCorrode library](<https://devfeed.tech/topics/autocorrode-library.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [boris-cherny](<https://devfeed.tech/tags/boris-cherny.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [race-conditions](<https://devfeed.tech/tags/race-conditions.md>), [tla-plus](<https://devfeed.tech/tags/tla-plus.md>)

### AI overview

The article explains that TLA+ can model complex concurrent systems and check properties such as invariants, while emphasizing that formal methods cannot guarantee correct code or verify properties that have not been specified. It cautions against treating formal verification as a complete solution for agentic software development.

### Source excerpt

Last week Boris Cherny, the inventor of Claude Code, mentioned that Opus was able to use TLA+1 to find race conditions in code. And now everybody on the internet is talking about formal verification. As a long-time educator (1 2) and advocate of TLA+, this is really exciting! TLA+ is great at designing complex concurrent systems and making sure they're bug-free.2 As a long-time advocate of level-headedness, this new euphoria worries me. I read a lot of people saying that formal methods will solve the problem of agentic software development once and for all, and that's nonsense. Enough words have been spilled about the weaknesses of TLA+ in terms of what it can guarantee, like how correct designs don't automatically translate into correct code. So I'd like to focus on a different limitation for this newsletter: to verify a property, we need to have a property to verify! So what are the properties that TLA+ can't even express? (This assumes some basic knowledge of TLA+. If you're a total beginner, check out those [1] [2] things above or read here.) What TLA+ can check TLA+ divides the system into a set of behaviors. Each behavior is a sequence of states, like "light one is green, then yellow, then red". In each state we can express a regular boolean expressions like "Light four is green" or "All lights are red." We can also modify expressions with three "temporal" logical operators: []P ("always P") is true if P is true in the current state and every future state. Example: [](at_most_one_green) is true if every state going forward has no more than one green light. P' ("P prime") is true if P is true in the next state. Example: light="green" && light'="red" is true if the light changes from green to red. <>P ("eventually P") is true if P is true in the current state or in at least one future state. Example: <>(light4 = "yellow") is true if light4 is yellow or is yellow in a future state. When we say that P is a property of the system, we mean it is true in the initial

## Investigating whether LLMs disproportionately use "spine" in GitHub pull request titles

DevFeed: [Investigating whether LLMs disproportionately use "spine" in GitHub pull request titles](<https://devfeed.tech/articles/the-llms-yearn-for-the-spines-32318.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/the-llms-yearn-for-the-spines/>)

Author: Hillel Wayne

Published: 2026-09-16T19:58:30Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [anthropic](<https://devfeed.tech/topics/anthropic.md>), [cursor](<https://devfeed.tech/topics/cursor.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [ai](<https://devfeed.tech/tags/ai.md>), [claude](<https://devfeed.tech/tags/claude.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [github](<https://devfeed.tech/tags/github.md>), [llms](<https://devfeed.tech/tags/llms.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>)

### AI overview

The article investigates whether large language models disproportionately use the word "spine" in GitHub pull request titles. Using GitHub Search as a proxy, it finds a much larger increase in "spine" pull requests than overall pull requests, but does not establish that the pattern comes from one specific model; sampled pull requests were coauthored by Claude or Cursor.

### Source excerpt

Earlier this year I worked on a couple of AI-generated TLA+ specifications, and one thing I've noticed was that they all used the word "spine" somewhere. Then I saw some non-TLA+ public projects use "spine" too and got curious if it was a new LLMism (LLisM?). If it is, we should see it appear in a discontinuous jump in the number of code projects that use "spine". The proper way to thoroughly explore this would be via the GitHub archive data dump but that'd take forever and I have a full time job now. Instead, I'm going to use GitHub Search. We can't filter code samples by date but can filter pull requests, which seems like an acceptable enough proxy. Here's a graph of the number of public PRs each year with "spine" in the title: I stopped 2026 at 2026-09-01, meaning the first nine months of this year have seen 20 times more "spine" PRs as all of 2025. Now it could be the case that that GitHub grew, like, a lot in the last year. Maybe the 20x increase is due there being 20x as many pull requests. We can account for this by comparing it against all public PRs:1 If "spine" wasn't an LLisM, we would expect only a 1.5xish increase from 2025, not a 20x increase. One other possible confounder could be that LLMs don't like the word spine but PRs Georg submitted 15,000 changes to a chiropractor repo. I will deal with this issue by ignoring it. Can we figure out which models specifically are obsessed with spines? Let's try breaking the change down by month: Looking at LLM timeline, the only widely-used model released in May was Opus 4.8, which came out too late in the month to explain the spike. GPT 5.5 came out in April, which could be the cause. But I'm not convinced by this. For one, the spine count is still 1.5xing each month before April, and I definitely remember seeing spines as early as February. Also, I spot checked and many of the PRs that use "spine" are coauthored by Claude or Cursor. So I think it's not specific to one LLM, but could be convinced otherwise. Othe

## Vim wants you to control, VSCode wants you to consume

DevFeed: [Vim wants you to control, VSCode wants you to consume](<https://devfeed.tech/articles/vim-wants-you-to-control-vscode-wants-you-to-consume-25508.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/vim-wants-you-to-control-vscode-wants-you-to/>)

Author: Hillel Wayne

Published: 2026-08-18T16:26:05Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Vim](<https://devfeed.tech/topics/vim.md>), [Neovim](<https://devfeed.tech/topics/neovim.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Emacs](<https://devfeed.tech/topics/emacs.md>)

Tags: [command-line](<https://devfeed.tech/tags/command-line.md>), [config](<https://devfeed.tech/tags/config.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [vim](<https://devfeed.tech/tags/vim.md>), [vscode](<https://devfeed.tech/tags/vscode.md>)

### AI overview

The article contrasts Vim and Neovim's programmable, state-oriented configuration with VSCode's static configuration and fixed built-in commands. It argues that Vim-based editors provide substantially more direct control over editor behavior, while also requiring more configuration and commitment.

### Source excerpt

Newsletter updates were sporadic in July because of two weddings, two conferences (with two different talks!), and finishing Logic for Programmers. Huge thank you to everybody who bought a copy, as well as for your patience with the schedule. There's some podcast appearances, a conf talk, and a book sale at the end of this post. Newsletter updates will be sporadic in August because I just started my Developer Educator job at Antithesis. I'll have less time to write because I'll be working 40 hour workweeks, about 8 hours of which being actual work and the other 32 being bashing my head against NixOS. NixOS is the standard developer OS at the company. It's also a notoriously difficult distro to learn even for Linux heads, and I'm coming from Windows. The only way I am going to get anywhere is to go all in and commit fully to the NixOS philosophy.1 For one, I'm seeing how long I can last without my customary 2000-line Neovim config. Which immediately raises the question as to why I have 2000 lines of Neovim config. It's because Vim2 (and Emacs) think of configuration in a very different way than more popular editors do. Control and Consumption Say we want to make ctrl+n to save the current file. In VSCode, you put this in keybindings.json: [ { "key": "ctrl+n", "command": "workbench.action.files.save" } ] In Neovim, you put this in init.lua: vim.keymap.set('n', '<c-n>', function() vim.cmd.write() end) Now, a couple of differences to see. First, the VSCode example is invoking a fixed, built-in command, while Neovim can bind an arbitrary function. Second, in VSCode you edit a static configuration file with static data, while in Neovim you execute a command that edits the running editor state. In fact, it doesn't even need to be in a configuration file: you can add a new keymap directly from the command line. Though you'd probably instead do that command in the OG Vim way: map <c-n> :w<CR> And that does something different than a function: it makes pressing ctrl+n mean "d

## Logic for Programmers is Done

DevFeed: [Logic for Programmers is Done](<https://devfeed.tech/articles/logic-for-programmers-is-done-25491.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/logic-for-programmers-is-done/>)

Author: Hillel Wayne

Published: 2026-07-29T15:43:52Z

Content type: release

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Publishing](<https://devfeed.tech/topics/publishing.md>), [LaTeX](<https://devfeed.tech/topics/latex.md>)

Tags: [announcement](<https://devfeed.tech/tags/announcement.md>), [blog](<https://devfeed.tech/tags/blog.md>), [book](<https://devfeed.tech/tags/book.md>), [free](<https://devfeed.tech/tags/free.md>), [latex](<https://devfeed.tech/tags/latex.md>), [typography](<https://devfeed.tech/tags/typography.md>)

### AI overview

Logic for Programmers has reached version 1.0 and is available in print. Early ebook buyers can download the completed edition for free through Leanpub.

### Source excerpt

It's done. Logic for Programmers is now 1.0 and available in print. Full announcement here, official website here, direct Amazon link here. If you got an early version of the ebook, you can go back to leanpub to download the 1.0 for free. This marks the completion of a project that took five years of work, six bookwriting professionals, fourteen domain experts, and fifteen public alphas. This has been, without a doubt, the biggest and most exhausting project I've ever done. The examples in the discarded drafts alone could make a second book. The cursed knowledge I've gained on LaTeX and typography could fill a third (or at least a couple of entertaining blog posts). Self-publishing was simultaneously the worst and best decision I made. Now excuse me I am going to sleep for a month.

## Logic for Programmers v0.15, Livecoding

DevFeed: [Logic for Programmers v0.15, Livecoding](<https://devfeed.tech/articles/logic-for-programmers-v0-15-livecoding-25493.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/logic-for-programmers-v015-livecoding/>)

Author: Hillel Wayne

Published: 2026-06-17T16:40:09Z

Content type: release

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [book](<https://devfeed.tech/tags/book.md>), [candidate](<https://devfeed.tech/tags/candidate.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [logic-for-programmers](<https://devfeed.tech/tags/logic-for-programmers.md>), [meetup](<https://devfeed.tech/tags/meetup.md>), [music](<https://devfeed.tech/tags/music.md>), [newsletter](<https://devfeed.tech/tags/newsletter.md>), [recommendations](<https://devfeed.tech/tags/recommendations.md>), [release](<https://devfeed.tech/tags/release.md>)

### AI overview

Logic for Programmers v0.15 is described as its first true release candidate: the content is complete, copy edited and proofread, with minor touch-ups remaining. The author expects the next release to be 1.0 in print unless a major issue arises, and is testing a smaller, low-margin PDF for screens; the printed book will have larger margins. At a livecoding meetup, Strudel was presented as an extensive JavaScript DSL that seems relatively approachable, while CLAVIER-36 uses a purpose-built language whose program is a 2D grid. The text identifies Strudel as a port of Haskell's TidalCycles and says C36 was inspired by Orca.

### Source excerpt

There's a new release of Logic for Programmers! This one, version 0.15, is the first true release candidate. There's a couple of minor touch-ups I need to do but all content is in and copy edited and proofread. Unless something absolutely major comes up, the next release will be 1.0 and available in print. Full release notes here. (I'm also testing if a smaller low margin PDF is better for phones and computers. The printed book is going to have much larger proper margins. Let me know what you think about this experiment!) Anyway I hurt my wrist and can't write a whole newsletter, so I'll just do a couple of recommendations. My friend Richard Whaling invited me to the inaugural livecode.chicago meetup, which was pretty cool! Among other things, people demoed two languages for livecoding music: Strudel is an extensive javascript DSL that seems relatively friendly to get into CLAVIER-36 is a ground-up special purpose language where the program is a 2D grid It all kinda makes me wish I knew the basics of music because it seems like it'd be a lot of fun to compare and contrast all of the various approaches to livecoding languages. Check em out if that's at all your thing! (For completeness, Strudel is a port of the Haskell TidalCycles and C36 was inspired by Orca)

## Nontrailing separators do not spark joy

DevFeed: [Nontrailing separators do not spark joy](<https://devfeed.tech/articles/nontrailing-separators-do-not-spark-joy-25499.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/nontrailing-separators-do-not-spark-joy/>)

Author: Hillel Wayne

Published: 2026-06-10T12:22:04Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [markup](<https://devfeed.tech/topics/markup.md>)

Tags: [alloy](<https://devfeed.tech/tags/alloy.md>), [better](<https://devfeed.tech/tags/better.md>), [change](<https://devfeed.tech/tags/change.md>), [design](<https://devfeed.tech/tags/design.md>), [grammar](<https://devfeed.tech/tags/grammar.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [json](<https://devfeed.tech/tags/json.md>), [prolog](<https://devfeed.tech/tags/prolog.md>), [tla-plus](<https://devfeed.tech/tags/tla-plus.md>)

### AI overview

The author argues that banning trailing separators makes edits to lists and records uneven: adding or removing a final item requires extra punctuation changes, unlike edits elsewhere. Examples include JSON, Haskell record fields, TLA+ variables, and Prolog, whose clauses also end with a period. The excerpt contrasts these with Python and Go, which allow trailing commas, TLA+ leading conjunctions and disjunctions, and Alloy, which allows both leading and trailing commas as well as empty separators. The author favors flexible separators, while noting that a parsing ambiguity argument against trailing separators will be considered; the excerpt ends before that argument is explained.

### Source excerpt

This is valid JSON: { "a": 1, "b": 2, "c": 3 } This is invalid JSON: { "a": 1, "b": 2, "c": 3, } The difference is the last comma. The JSON grammar specifies that a comma can separate two members of an object but not postcede ("trail") a member. I think this was a design mistake. Say we want to add two new keys to the struct, one before the "a" member and one after the "c" member. Here's what it would look like if trailing commas were permitted: { + "x": 0, "a": 1, "b": 2, "c": 3, + "y": 4, } It's the exact same text transformation regardless of where we add the key. In the current model, we instead have this: { + "x": 0, "a": 1, "b": 2, - "c": 3 + "c": 3, + "y": 4 } Those are different transformations! Similarly if you want to remove an element, you can't just delete the corresponding line1, you have to delete the line and then check that the last line doesn't have a trailing comma. Don't even get me started on all the special cases involved in swapping two lines. JSON isn't the only language with this problem. Haskell writes record types like this: -- from https://play.haskell.org/ data Drone = Drone { xPos :: Int , yPos :: Int , zPos :: Int } This "partial bullet point" style of putting separators at the beginning of rows makes it easier to change the last row but harder to change the first one. TLA+ has this problem too: \* both valid VARIABLES a, b, c vars == <<a, b, c>> \* both invalid VARIABLES a, b, c, vars == <<a, b, c,>> This one's annoying because 1) you're constantly adding new top-level variables while working on a spec and 2) the PlusCal DSL does not have this problem: \* Totally fine! (*--algorithm foo { variables a; b; c; The worst offenders, IMO, are logic languages like Prolog. Not only don't you have trailing separators, you have a special terminating symbol: foo(A, B, C) :- A = 1, % comma B = 2, % comma C = 3. % period! I guess you can sort of think of it as funny-lookin' braces: foo(A, B, C) :- A = 1, B = 2, C = 3 . But this is not standard synt

## Logic for Programmers extra credits

DevFeed: [Logic for Programmers extra credits](<https://devfeed.tech/articles/logic-for-programmers-extra-credits-25490.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/logic-for-programmers-extra-credits/>)

Author: Hillel Wayne

Published: 2026-06-02T14:48:48Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Learning](<https://devfeed.tech/topics/learning.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [logic](<https://devfeed.tech/tags/logic.md>), [logic-for-programmers](<https://devfeed.tech/tags/logic-for-programmers.md>), [math](<https://devfeed.tech/tags/math.md>), [type-theory](<https://devfeed.tech/tags/type-theory.md>)

### AI overview

Four supplements to Logic for Programmers cover counting orderings of concurrent processes; first-order logic over sets of functions, including currying and type theory; Barbara Liskov's history rule in subtyping; and total and partial orders on sets. The author says these short math pieces were written off the cuff and may be rough or contain errors, unlike the book's more intensive editing.

### Source excerpt

So I said there wasn't a proper newsletter this week, since I'm in Budapest prepping for a conference. But I still got a thing for y'all. There's a lot of interesting topics I wanted to cover for Logic for Programmers, but the book is dense enough as it is and many of these were too tangential or technical to fit in well. So I've been writing some supplements and uploading them here. I've got four so far: How we compute the number of orderings of multiple concurrent processes How first-order logic can quantify over "a set of functions", what a "set of functions" looks like, and how functions can be defined in terms of sets (plus a bit on currying and type theory) Barbara Liskov's "history rule" in subtyping Total and partial orders on sets. Now I'm going to caveat that these were written off the cuff and haven't gone through the obsessive editing of the book itself, so they may be rough and there might be errors in them. Still, it's like 2-3000 words of math content, so hopefully covers not having a proper newsletter this time. Seeya next week!

## Knowing about things is cheaper than knowing things

DevFeed: [Knowing about things is cheaper than knowing things](<https://devfeed.tech/articles/knowing-about-things-is-cheaper-than-knowing-things-25488.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/knowing-about-things-is-cheaper-than-knowing/>)

Author: Hillel Wayne

Published: 2026-05-28T16:03:01Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [learn programming](<https://devfeed.tech/topics/learn-programming.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>)

Tags: [knowledge](<https://devfeed.tech/tags/knowledge.md>), [learning](<https://devfeed.tech/tags/learning.md>), [math](<https://devfeed.tech/tags/math.md>), [programming](<https://devfeed.tech/tags/programming.md>), [regular-expressions](<https://devfeed.tech/tags/regular-expressions.md>), [shell-scripting](<https://devfeed.tech/tags/shell-scripting.md>)

### AI overview

Broad exposure helps programmers discover which math may be useful in their own work, while learning any one advanced field in depth is unlikely to pay off for most programmers. The author distinguishes basic math useful across programming, such as arithmetic, from specialized fields that benefit particular domains. They argue that programmers need a general sense of what fields exist, their core ideas, and where they apply before choosing what to study deeply. Their practical suggestions are non-honors undergraduate textbooks and conference videos, approached as learning for its own sake. The excerpt ends mid-thought.

### Source excerpt

Short one this week because I'm way behind on book and conference prep. Last week a LinkedIn Influencer wrote about how math has nothing to do with programming, so I spite-wrote a rejoinder about how math is necessary to program (just try to write software without knowing arithmetic!) and man I forgot how much spite can fuel writing. Maybe I should go back to Twitter (absolutely not). But it got me thinking about the difference between "all programmers can benefit from learning math" and "all programmers need to learn math". I simultaneously believe three things: There is some math, like arithmetic (incl. arithmetic of booleans, sets, functions, etc), that is useful to all programmers. The remaining fields aren't useful to most programmers. Every programmer works in a domain where there is at least one branch of math that would benefit them to learn. (2) means that if get a group of 100 software engineers and teach them something like algebra or calculus, you can't expect it to be applicable for more than 3 or 5. Whereas if you teach something like shell scripting or regular expressions it'd be useful to at least, like, 50. So no field of math has a good RoI for the average programmer. (3) means that each of those 100 developers could, on their own, find a field of math that is useful to them. In order to do that, though, they need to roughly know what the fields are, what the big ideas are, and where they might be useful. It is more useful to teach them about many fields than to teach them any one specific field in-depth. I think that's generally true with most areas of knowledge! Getting basic exposure to something takes a lot less time and effort than learning it in-depth. If you're specifically trying to learn things that will be useful to your work1, you only want to go in-depth on topics you know will be helpful. But you won't know the topic is helpful (or even that it exists) unless you know the very basics already. So it makes sense to get broad exposure to

## Assumptions weaken properties

DevFeed: [Assumptions weaken properties](<https://devfeed.tech/articles/assumptions-weaken-properties-25481.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/assumptions-weaken-properties/>)

Author: Hillel Wayne

Published: 2026-05-20T15:13:16Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>)

Tags: [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [json](<https://devfeed.tech/tags/json.md>), [logic](<https://devfeed.tech/tags/logic.md>), [properties](<https://devfeed.tech/tags/properties.md>)

### AI overview

Adding assumptions weakens a property: if a system guarantees Prop outright, it also guarantees Prop whenever an assumption holds, but the conditional guarantee covers fewer cases. The excerpt illustrates this with JSON parsing: correctness for valid ASCII JSON is weaker than correctness for valid JSON across Unicode. It also distinguishes a specification failure from a runtime assumption failing: a system can meet a conditional specification yet appear buggy when the assumption is false. The excerpt begins to explain why assumptions are used, noting that some properties are unsatisfiable without them, such as requiring a computer to always return a sorted list if it can be stopped before returning.

### Source excerpt

In some tests are stronger than others, I defined STRONG => WEAK to mean "any system passing test STRONG is also guaranteed to pass WEAK". This uses the logical implication operator, defined as P => Q = !P || (P && Q). Implication may be the most overworked operator in logic. Among other things, it's also used in formal specification, where Spec => Prop means "any system satisfying Spec has property Prop" and ASSUME => Spec means "The assumption ASSUME must hold in order for the system to satisfy Spec." Now let's mush these all together and do some math. To start, "the system has property Prop" is the same as "the system passes the test that checks Prop", so test strength is also property strength. Now let "ASSUME => Prop" mean "the system passes Prop assuming ASSUME is true." In classic logic, if P is true, then obviously !Q || P is true. Further, that is equivalent (just draw the truth table!) to !Q || (P && Q). So for any propositions P and Q, P => (Q => P). In other words, Prop => (ASSUME => Prop). In other other words, "the system passes Prop" is a stronger property than "the system passes Prop whenever our assumptions hold." In other other other words, any assumption added makes a property weaker. This makes intuitive sense to me. A JSON parser that's only been verified with ASCII strings has the property "input only uses ASCII && is valid json => correctly parsed". A better JSON parser that works for all Unicode will have the property "is valid json => correctly parsed", which has fewer assumptions, meaning it's guaranteed to work in a strict superset of cases. It also matches the intuition that "more assumptions means more likely to go wrong". We have a bug whenever Prop is false. The only way for Spec => Prop to be true and Prop be false is if Spec is false, eg our system doesn't satisfy the specification we intended to implement. On the other hand, Spec => (ASSUME => Prop) && !Prop is true whenever Spec and/or ASSUME is false, meaning a correctly-implement

## Points are a weird and inconsistent unit of measure

DevFeed: [Points are a weird and inconsistent unit of measure](<https://devfeed.tech/articles/points-are-a-weird-and-inconsistent-unit-of-measure-25502.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/points-are-a-weird-and-inconsistent-unit-of/>)

Author: Hillel Wayne

Published: 2026-05-13T15:56:37Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [LaTeX](<https://devfeed.tech/topics/latex.md>), [TeX](<https://devfeed.tech/topics/tex.md>)

Tags: [articles](<https://devfeed.tech/tags/articles.md>), [latex](<https://devfeed.tech/tags/latex.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

The author investigates why a 10.8pt x 7.2pt grid differs between LaTeX and Inkscape. The article explains that point definitions varied historically and that TeX uses a slightly different point size from the official printer's point.

### Source excerpt

I'm in the middle of redoing the Logic for Programmers diagrams and this has surfaced a really annoying problem. The book is formatted in LaTeX using a pseudo-grid of 10.8pt x 7.2pt. The diagrams are done in Inkscape using a 10.8pt x 7.2pt. Last week I found out that these are not the same points. Latex defines a point as 1/72.27 inches (0.3515 millimeters). Inkscape instead uses 1/72 inches (0.3528 mm). It's only a difference of 0.4% but it still floors me that two widespread digital technologies would be different! So, uh, what happened? A few hours of reading articles later, this is what I found, caveat that I didn't spend all that much time researching this and this is only initial impressions. what even is a point A point is a typographic measure, coming from 1517, that is supposedly the smallest interesting size for a printer. This was notably not a standardized measure- different companies in times used different point sizes depending on their equipment. Over time it was standardized, but each country picked a different standard: the German and Japanese point is 0.250 mm, the French point is allegedly 0.399 mm, etc. But early computer history is super Americentric so that's what technology uses. In the US, they standardized the point around the end of the 19th century. To what? I dunno. This source from 1900 gives the length of a point as 35/996 cm (72.281 points/in) and then says there are exactly 867.4699 "ems per foot" (72.289 points/in). This source from 1916 says the standard pica (12 points) is 0.16604 inches and that there are 72.272 "pica ems per foot". Which conveniently enough gives us 72.272 points/in (a pica being 12 points). Then on the very next page they say no a pica is actually 0.166044 inches and a point is exactly 0.013837 inches. I found other sources with other definitions, too. I'm going to chalk the differences up to a mix of "the definitions of 'meter' and 'foot' changed over time" and "these are less than a micron apart so who gives a

## New Logic for Programmers (and the future of this newsletter)

DevFeed: [New Logic for Programmers (and the future of this newsletter)](<https://devfeed.tech/articles/new-logic-for-programmers-and-the-future-of-this-newsletter-25497.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/new-logic-for-programmers-and-the-future-of-this/>)

Author: Hillel Wayne

Published: 2026-05-06T17:03:46Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Formal methods](<https://devfeed.tech/topics/formal-methods.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [developer](<https://devfeed.tech/tags/developer.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [newsletter](<https://devfeed.tech/tags/newsletter.md>), [release](<https://devfeed.tech/tags/release.md>), [testing](<https://devfeed.tech/tags/testing.md>), [updates](<https://devfeed.tech/tags/updates.md>)

### AI overview

The author announces version 0.14 of Logic for Programmers, reports progress toward a 1.0 print edition, and shares plans to join Antithesis as a developer educator. The newsletter may shift toward software history and related topics, with its future publishing frequency uncertain.

### Source excerpt

So first the immediate news: I just released version 0.14 of Logic for Programmers! This release is pretty similar to 0.13. There are a few rewrites but the vast majority of the changes are layout, copyediting, and technical editing. Full notes here. In related news, I've started doing test prints of the book: There's not a whole lot left to be done. I've gotta fix up some diagrams, do more formatting and proofreading, incorporate some fixes raised by readers, and make a website and back cover. After that, the book should be ready for 1.0. I'm aiming to have print copies purchasable by the end of June! Now the big news: starting August, I'll be a full-time employee of Antithesis, a generative testing platform. Officially my role is "developer educator", and I'll be tasked with making "property-based testing, fuzzing, fault injection, Hegel, Bombadil, and the Antithesis platform understandable to everyday engineers". So the same kind of work I do now, except with far more support and a matching 401(k). I already have three pages of topic ideas you have no idea how excited I am about this So how is this going to affect the newsletter? First, I want to make clear that this is not going to become an Antithesis newsletter. My Antithesis-related work is going to be on their official platforms. I do think one of the best ways to make a topic "understandable" is to write foundational material that's useful to all engineers, whether they're invested in the topic or not. I might share links to things I make along those lines, but they'll be just that, links. At the same time, the content of this newsletter will change a little. Property testing and fuzzing aren't the same as formal methods, but a lot of the foundations overlap, especially in how we think about properties and correctness. I don't know for sure yet, but I suspect that I'll start biasing this newsletter away from Antithesis related topics. So there will probably be less theoretic things like what does undecidabl

## Illegal vs Unwanted States

DevFeed: [Illegal vs Unwanted States](<https://devfeed.tech/articles/illegal-vs-unwanted-states-25485.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/illegal-vs-unwanted-states/>)

Author: Hillel Wayne

Published: 2026-04-28T15:14:09Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [systems](<https://devfeed.tech/topics/systems.md>), [Software](<https://devfeed.tech/topics/software.md>), [data](<https://devfeed.tech/topics/data.md>), [Network](<https://devfeed.tech/topics/network.md>), [Server](<https://devfeed.tech/topics/server.md>)

Tags: [airline](<https://devfeed.tech/tags/airline.md>), [data](<https://devfeed.tech/tags/data.md>), [data-type](<https://devfeed.tech/tags/data-type.md>), [event](<https://devfeed.tech/tags/event.md>), [network](<https://devfeed.tech/tags/network.md>), [optional](<https://devfeed.tech/tags/optional.md>), [servers](<https://devfeed.tech/tags/servers.md>), [software](<https://devfeed.tech/tags/software.md>), [state](<https://devfeed.tech/tags/state.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article distinguishes illegal states, which a system must never enter, from unwanted states, which may be temporarily acceptable but must not persist or develop into illegal states. It argues that systems should represent unwanted states because external inputs and unreliable infrastructure make them unavoidable, while detection and resolution mechanisms limit their consequences.

### Source excerpt

An illegal state is a state we never want our system to be in. An unwanted state is a state we don't want to stay in. Many states that we wish were illegal are actually unwanted. Considering a calendaring software which stores calendar events as {user: {events: [event]}}, where each event has a start and end time. This allows one person to attend two events at the same time. We might consider this illegal and replace the data type with {user: {time: optional event}} which makes this impossible. However, a scheduling conflict isn't illegal, only unwanted! It is possible for a person to sign up for two overlapping events. Maybe they're supposed to choose one event, maybe they'll decide which event to go to later, maybe one of the events doesn't actually represent an in-person meeting. In that case it's acceptable, if not ideal, to remain in the unwanted state. Other unwanted states lead to invalid states if not exited quickly. An airline flight is in an unwanted state if there are more passengers booked to fly than seats available. This must be resolved before passengers actually board, as "more passengers physically on the plane than seats available" is an illegal state. In some cases, an unwanted state does not lead to illegal states, but permanently remaining in the unwanted state is still a problem. We might guarantee that a network partition does not ever lead to inconsistent data. Even though the unwanted state of a network partition cannot cause the illegal state of corrupt data, we still have a big problem if we don't ever fix the partition. Why systems must represent unwanted states Generally, unwanted states can happen if we don't have complete control over our system's behavior. We can't guarantee our network is perfectly reliable, our servers are always up, our users all put in correct data. If our system gets input from the external world then the world can push us into an unwanted state. We need to be able to detect these states so we can resolve them. E

## A sufficiently comprehensive spec is not (necessarily) code

DevFeed: [A sufficiently comprehensive spec is not (necessarily) code](<https://devfeed.tech/articles/a-sufficiently-comprehensive-spec-is-not-necessarily-code-25479.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/a-sufficiently-comprehensive-spec-is-not/>)

Author: Hillel Wayne

Published: 2026-04-15T16:18:02Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Code](<https://devfeed.tech/topics/code.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [2019](<https://devfeed.tech/tags/2019.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [app](<https://devfeed.tech/tags/app.md>), [automatic](<https://devfeed.tech/tags/automatic.md>), [best](<https://devfeed.tech/tags/best.md>), [business](<https://devfeed.tech/tags/business.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [command](<https://devfeed.tech/tags/command.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [consider](<https://devfeed.tech/tags/consider.md>), [conversion](<https://devfeed.tech/tags/conversion.md>), [design](<https://devfeed.tech/tags/design.md>), [details](<https://devfeed.tech/tags/details.md>), [don-t](<https://devfeed.tech/tags/don-t.md>), [spec](<https://devfeed.tech/tags/spec.md>)

### AI overview

A specification remains distinct from code whenever it allows multiple implementations: code is one program in the set that satisfies the spec. The miles-to-kilometers example shows how adding requirements such as a website textbox narrows that set but still leaves choices about language, interface, and conversion precision. Whether the spec is sufficiently precise depends on whether the resulting program solves the requester's problem. The excerpt also notes that automatically generating a program from a spec is the separate research field of program synthesis; the author's 2019 recollection is limited to generating local functions from type specifications.

### Source excerpt

Sorry for missing last week! Was sick and then busy. This week I want to cover a pet peeve of mine, best seen in this comic: A "comprehensive and precise spec" is not necessarily code. A specification corresponds to a set of possible implementations, and code is a single implementation in that set. As long as the set has more than one element, there is a separation between the spec and the code. Consider a business person (bp) who asks: I want a tool to convert miles to kilometers. Is this a comprehensive spec? Maybe, you can give it to Claude Code and tell it to make all design decisions and it will give you a program that converts miles to km. At the same time, there is a huge amount of details left out of this. What language? What's the UX? Should it be a command line script or a mobile app or an enterprise SaaS? For this reason, if we gave Claude's output to the bp, they'll probably be unsatisfied. The set of possible implementations includes the programs they want, but also lots of programs they don't want. So they now they say: It should be a textbox on a website. Okay, this rules out a lot more stuff, but there's still a lot to decide. React or vanillajs or htmx? Should the output be a separate textbox or a popup? Should we use a conversion of 1.6, 1.61, or 1.609? So you could argue that this is still not a "comprehensive and precise spec". But what if the bp is happy with whatever Claude makes? Then their spec was sufficiently comprehensive and precise, since they got a program that solved their problem! Now the comic above makes the more specific claim that a spec "comprehensive and precise enough to generate a program" is code. That wasn't even true before LLMs. Program synthesis, the automatic generation of conformant programs from specifications, is an active field of research! Last I checked in 2019 they were only generating local functions from type specifications; I don't know how things have changed with LLMs. But still, it shows that code and compre

## Choose Boring Technology and Innovative Practices

DevFeed: [Choose Boring Technology and Innovative Practices](<https://devfeed.tech/articles/choose-boring-technology-and-innovative-practices-25482.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/choose-boring-technology-and-innovative-practices/>)

Author: Hillel Wayne

Published: 2026-03-24T14:38:06Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Software Process](<https://devfeed.tech/topics/software-process.md>), [legacy systems](<https://devfeed.tech/topics/legacy-systems.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [tech radar](<https://devfeed.tech/topics/tech-radar.md>), [Database](<https://devfeed.tech/topics/database.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [innovation](<https://devfeed.tech/tags/innovation.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [material](<https://devfeed.tech/tags/material.md>), [practices](<https://devfeed.tech/tags/practices.md>), [technology](<https://devfeed.tech/tags/technology.md>), [tools](<https://devfeed.tech/tags/tools.md>)

### AI overview

The excerpt argues that teams should be cautious about mission-critical technology because unfamiliar systems bring unknown pitfalls and lasting maintenance costs, while abandoning them can require costly migration or continued support. Practices such as test && commit || revert are easier to adopt and drop, so teams can experiment more freely with them, though social processes may take more work to sustain. It then distinguishes business-critical "material" (code, architecture, data and databases) from tools used to create it (such as editors and personal bash scripts), using the cost of losing each as the dividing test; the excerpt ends before developing this distinction further.

### Source excerpt

The famous article Choose Boring Technology lists two problems with using innovative technology: There are too many "unknown unknowns" in a new technology, whereas in boring technology the pitfalls are already well-known. Shiny tech has a maintenance burden that persist long after everybody has gotten bored with it. Both of these tie back to the idea that the main cost of technology is maintenance. Even if something is easy to build with, it might not be as easy to keep running. We cannot "abandon" mission-critical technology. Say my team builds a new service on Julia, and 2 years later decides it was the wrong choice. We're stuck with either the (expensive) process of migrating all our data to Postgres code to Java or the (expensive) process of keeping it running anyway. Either way, the company needs to spend resources keeping engineers trained on the tech instead of other useful things, like how to mine crypto in their heads. Tech is slow to change. Not as slow to change as, say, a bridge, but still pretty slow. Now say at the same time as Julia, we also decided to start practicing test && commit || revert (TCR). After two years, we get sick of that, too. To deal with this, we can simply... not do TCR anymore. There is no "legacy practice" we need to support, no maintenance burden to dropping a process. It is much easier to adopt and abandon practices than it is to adopt and abandon technology. This means while we should be conservative in the software we use, we can be more freely innovative in how we use it. If we get three innovation tokens for technology, we get like six or seven for practices. And we can trade in our practices to get those tokens back. (The flip side of this is that social processes are less "stable" than technology and take more work to keep running. This is why "engineering controls" are considered more effective as reducing accidents than administrative controls.) Choose Boring Material and Innovative Tools Pushing this argument further, w

## LLMs are bad at vibing specifications

DevFeed: [LLMs are bad at vibing specifications](<https://devfeed.tech/articles/llms-are-bad-at-vibing-specifications-25489.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/llms-are-bad-at-vibing-specifications/>)

Author: Hillel Wayne

Published: 2026-03-10T17:12:30Z

Content type: opinion

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [alloy](<https://devfeed.tech/tags/alloy.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [llms](<https://devfeed.tech/tags/llms.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [tla-plus](<https://devfeed.tech/tags/tla-plus.md>)

### AI overview

The author argues that AI-generated formal specifications can look plausible while missing both basic correctness and meaningful verification. In the Alloy example, the spec does not compile because it uses the Boolean module without importing it, and the author says modeling signed status with a Boolean is the wrong approach; the assertions are tautologies that check little beyond the definition. The excerpt says TLA+ has an official MCP server that lets an agent run model checking, but the author still sees likely-invalid specs and mostly "obvious" properties. Those can catch missed guards or variable updates, while the author says formal methods' value lies in subtle properties involving concurrency, nondeterminism, or behavior across several steps. The excerpt does not include the full examples or article.

### Source excerpt

No newsletter next week I'll be speaking at InfoQ London. But see below for a book giveaway! LLMs are bad at vibing specifications About a year ago I wrote AI is a gamechanger for TLA+ users, which argued that AI are a "specification force multiplier". That was written from the perspective an TLA+ expert using these tools. A full 4% of Github TLA+ specs now have the word "Claude" somewhere in them. This is interesting to me, because it suggests there was always an interest in formal methods, people just lacked the skills to do it. It's also interesting because it gives me a sense of what happens when beginners use AI to write formal specs. It's not good. As a case study, we'll use this project, which is kind of enough to have vibed out TLA+ and Alloy specs. Looking at a project Starting with the Alloy spec. Here it is in its entirety: module ThreatIntelMesh sig Node {} one sig LocalNode extends Node {} sig Snapshot { owner: one Node, signed: one Bool, signatures: set Signature } sig Signature {} sig Policy { allowUnsignedImport: one Bool } pred canImport[p: Policy, s: Snapshot] { (p.allowUnsignedImport = True) or (s.signed = True) } assert UnsignedImportMustBeDenied { all p: Policy, s: Snapshot | p.allowUnsignedImport = False and s.signed = False implies not canImport[p, s] } assert SignedImportMayBeAccepted { all p: Policy, s: Snapshot | s.signed = True implies canImport[p, s] } check UnsignedImportMustBeDenied for 5 check SignedImportMayBeAccepted for 5 Couple of things to note here: first of all, this doesn't actually compile. It's using the Boolean standard module so needs open util/boolean to function. Second, Boolean is the wrong approach here; you're supposed to use subtyping. sig Snapshot { owner: one Node, - signed: one Bool, signatures: set Signature } + sig SignedSnapshot in Snapshot {} pred canImport[p: Policy, s: Snapshot] { - s.signed = True + s in SignedSnapshot } So we know the person did not actually run these specs. This is somewhat less of a probl

## Free Books

DevFeed: [Free Books](<https://devfeed.tech/articles/free-books-25483.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/free-books/>)

Author: Hillel Wayne

Published: 2026-03-03T16:34:33Z

Content type: release

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Mercury](<https://devfeed.tech/topics/mercury-lang.md>)

Tags: [am](<https://devfeed.tech/tags/am.md>), [books](<https://devfeed.tech/tags/books.md>), [bug](<https://devfeed.tech/tags/bug.md>), [europe](<https://devfeed.tech/tags/europe.md>), [free](<https://devfeed.tech/tags/free.md>), [leanpub](<https://devfeed.tech/tags/leanpub.md>), [logic-for-programmers](<https://devfeed.tech/tags/logic-for-programmers.md>)

### AI overview

The author skipped the newsletter and offered ten free copies of *Logic for Programmers*: five available immediately and five intended to become available at 10:30 AM CEST the next day to give readers in Europe a better chance. The author then noted that a Leanpub bug prevented the plan from working properly.

### Source excerpt

Spinning a lot of plates this week so skipping the newsletter. As an apology, have ten free copies of Logic for Programmers. These five are available now. These five should be available at 10:30 AM CEST tomorrow, so people in Europe have a better chance of nabbing one. Nevermind Leanpub had a bug that made this not work properly

## New Blog Post: Some Silly Z3 Scripts I Wrote

DevFeed: [New Blog Post: Some Silly Z3 Scripts I Wrote](<https://devfeed.tech/articles/new-blog-post-some-silly-z3-scripts-i-wrote-25496.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/new-blog-post-some-silly-z3-scripts-i-wrote/>)

Author: Hillel Wayne

Published: 2026-02-23T16:49:10Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Library](<https://devfeed.tech/topics/library.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [division-by-zero](<https://devfeed.tech/tags/division-by-zero.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [nested](<https://devfeed.tech/tags/nested.md>), [scripts](<https://devfeed.tech/tags/scripts.md>), [silly](<https://devfeed.tech/tags/silly.md>), [smt](<https://devfeed.tech/tags/smt.md>), [z3](<https://devfeed.tech/tags/z3.md>)

### AI overview

The post shares Z3 scripts drawn from material that did not make it into the roughly 50,000-word Logic for Programmers book. To demonstrate a conditioned property, the author chose a multiplicative inverse statement requiring a quantifier over a division-based alternative, which would have needed an explanation of Z3's total division semantics. This choice brought total operations back into the discussion of arrays. The author reports that an array example returns an unexplained maximum-profit value and speculates about optimizer short-circuiting on an ill-defined problem. An attempted Goldbach encoding to demonstrate SMT undecidability did not work; the author says nested quantifiers were difficult.

### Source excerpt

Now that I'm not spending all my time on Logic for Programmers, I have time to update my website again! So here's the first blog post in five months: Some Silly Z3 Scripts I Wrote. Normally I'd also put a link to the Patreon notes but I've decided I don't like publishing gated content and am going to wind that whole thing down. So some quick notes about this post: Part of the point is admittedly to hype up the eventual release of LfP. I want to start marketing the book, but don't want the marketing material to be devoid of interest, so tangentially-related-but-independent blog posts are a good place to start. The post discusses the concept of "chaff", the enormous quantity of material (both code samples and prose) that didn't make it into the book. The book is about 50,000 words... and considerably shorter than the total volume of chaff! I don't think most of it can be turned into useful public posts, but I'm not entirely opposed to the idea. Maybe some of the old chapters could be made into something? Coming up with a conditioned mathematical property to prove was a struggle. I had two candidates: a == b * c => a / b == c, which would have required a long tangent on how division must be total in Z3, and a != 0 => some b: b * a == 1, which would have required introducing a quantifier (SMT is real weird about quantifiers). Division by zero has already caused me enough grief so I went with the latter. This did mean I had to reintroduce "operations must be total" when talking about arrays. I have no idea why the array example returns 2 for the max profit and not 99999999. I'm guessing there's some short circuiting logic in the optimizer when the problem is ill-defined? One example I could not get working, which is unfortunate, was a demonstration of how SMT solvers are undecidable via encoding Goldbach's conjecture as an SMT problem. Anything with multiple nested quantifiers is a pain.

## Stream of Consciousness Driven Development

DevFeed: [Stream of Consciousness Driven Development](<https://devfeed.tech/articles/stream-of-consciousness-driven-development-25506.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/stream-of-consciousness-driven-development/>)

Author: Hillel Wayne

Published: 2026-02-18T16:33:08Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [software-development](<https://devfeed.tech/topics/software-development.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [pair\_programming](<https://devfeed.tech/topics/pair-programming.md>)

Tags: [chain-of-thought](<https://devfeed.tech/tags/chain-of-thought.md>), [client](<https://devfeed.tech/tags/client.md>), [computational-complexity](<https://devfeed.tech/tags/computational-complexity.md>), [development](<https://devfeed.tech/tags/development.md>), [experience](<https://devfeed.tech/tags/experience.md>), [explain](<https://devfeed.tech/tags/explain.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [pairing](<https://devfeed.tech/tags/pairing.md>), [partner](<https://devfeed.tech/tags/partner.md>), [question](<https://devfeed.tech/tags/question.md>), [quicksort](<https://devfeed.tech/tags/quicksort.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [solution](<https://devfeed.tech/tags/solution.md>), [sort](<https://devfeed.tech/tags/sort.md>), [spec](<https://devfeed.tech/tags/spec.md>), [want](<https://devfeed.tech/tags/want.md>)

### AI overview

When a spec change is conceptually complex, write out the reasoning together before editing the spec. The author created a Markdown file covering the problem, failed attempts, proposed solution, how it works, expected changes, and what it would not address. Questions and dead ends were added to the document as the discussion unfolded. They began changing the spec only after the client understood the reasoning and agreed with the approach. The author says this helped prevent a partner from deferring to the perceived expert and leaving behind a spec they could not maintain. The approach had been tried once and seemed promising, but requires substantial typing.

### Source excerpt

This is something I just tried out last week but it seems to have enough potential to be worth showing unpolished. I was pairing with a client on writing a spec. I saw a problem with the spec, a convoluted way of fixing the spec. Instead of trying to verbally explain it, I started by creating a new markdown file: NameOfProblem.md Then I started typing. First the problem summary, then a detailed description, then the solution and why it worked. When my partner asked questions, I incorporated his question and our discussion of it into the flow. If we hit a dead end with the solution, we marked it out as a dead end. Eventually the file looked something like this: Current state of spec Problems caused by this Elaboration of problems What we tried that didn't work Proposed Solution Theory behind proposed solution How the solution works Expected changes Other problems this helps solve Problems this does *not* help with Only once this was done, my partner fully understood the chain of thought, and we agreed it represented the right approach, did we start making changes to the spec. How is this better than just making the change? The change was conceptually complex. A rough analogy: imagine pairing with a beginner who wrote an insertion sort, and you want to replace it with quicksort. You need to explain why the insertion sort is too slow, why the quicksort isn't slow, and how quicksort actually correctly sorts a list. This could involve tangents into computational complexity, big-o notation, recursion, etc. These are all concepts you have internalized, so the change is simple to you, but the solution uses concepts the beginner does not know. So it's conceptually complex to them. I wasn't pairing with a beginning programmer or even a beginning specifier. This was a client who could confidently write complex specs on their own. But they don't work on specifications full time like I do. Any time there's a relative gap in experience in a pair, there's solutions that are concep

## Proving What's Possible

DevFeed: [Proving What's Possible](<https://devfeed.tech/articles/proving-what-s-possible-25503.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/proving-whats-possible/>)

Author: Hillel Wayne

Published: 2026-02-11T18:36:53Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Formal methods](<https://devfeed.tech/topics/formal-methods.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Finite-state machine](<https://devfeed.tech/topics/finite-state-machine.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [future](<https://devfeed.tech/tags/future.md>), [invariant](<https://devfeed.tech/tags/invariant.md>), [linear](<https://devfeed.tech/tags/linear.md>), [logic](<https://devfeed.tech/tags/logic.md>), [machine](<https://devfeed.tech/tags/machine.md>), [model](<https://devfeed.tech/tags/model.md>), [operators](<https://devfeed.tech/tags/operators.md>), [point](<https://devfeed.tech/tags/point.md>), [possible](<https://devfeed.tech/tags/possible.md>), [properties](<https://devfeed.tech/tags/properties.md>), [property](<https://devfeed.tech/tags/property.md>), [records](<https://devfeed.tech/tags/records.md>), [retry](<https://devfeed.tech/tags/retry.md>), [safety](<https://devfeed.tech/tags/safety.md>), [state](<https://devfeed.tech/tags/state.md>), [system](<https://devfeed.tech/tags/system.md>), [temporal](<https://devfeed.tech/tags/temporal.md>), [transaction](<https://devfeed.tech/tags/transaction.md>)

### AI overview

The excerpt argues that formal specifications sometimes need to express what a system can make happen, in addition to what must always hold or eventually occur. It introduces possibility properties as questions about whether a condition can arise at some point in a model; for state-based conditions, these are reachability properties. The author gives combinations such as a condition being possible from every state where another condition holds, and notes that possibility properties are often less useful than safety or liveness requirements but still matter. The excerpt cuts off before the promised example.

### Source excerpt

As a formal methods consultant I have to mathematically express properties of systems. I generally do this with two "temporal operators": A(x) means that x is always true. For example, a database table always satisfies all record-level constraints, and a state machine always makes valid transitions between states. If x is a statement about an individual state (as in the database but not state machine example), we further call it an invariant. E(x) means that x is "eventually" true, conventionally meaning "guaranteed true at some point in the future". A database transaction eventually completes or rolls back, a state machine eventually reaches the "done" state, etc. These come from linear temporal logic, which is the mainstream notation for expressing system properties. 1 We like these operators because they elegantly cover safety and liveness properties, and because we can combine them. A(E(x)) means x is true an infinite number of times, while A(x => E(y) means that x being true guarantees y true in the future. There's a third class of properties, that I will call possibility properties: P(x) is "can x happen in this model"? Is it possible for a table to have more than ten records? Can a state machine transition from "Done" to "Retry", even if it doesn't? Importantly, P(x) does not need to be possible immediately, just at some point in the future. It's possible to lose 100 dollars betting on slot machines, even if you only bet one dollar at a time. If x is a statement about an individual state, we can further call it a reachability property. I'm going to use the two interchangeably for flow. A(P(x)) says that x is always possible. No matter what we've done in our system, we can make x happen again. There's no way to do this with just A and E. Other meaningful combinations include: P(A(x)): there is a reachable state from which x is always true. A(x => P(y)): y is possible from any state where x is true. E(x && P(y)): There is always a future state where x is true a

## Logic for Programmers New Release and Next Steps

DevFeed: [Logic for Programmers New Release and Next Steps](<https://devfeed.tech/articles/logic-for-programmers-new-release-and-next-steps-25492.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/logic-for-programmers-new-release-and-next-steps/>)

Author: Hillel Wayne

Published: 2026-02-04T14:00:00Z

Content type: release

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Mercury](<https://devfeed.tech/topics/mercury-lang.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [alloy](<https://devfeed.tech/tags/alloy.md>), [api](<https://devfeed.tech/tags/api.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [data-modeling](<https://devfeed.tech/tags/data-modeling.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [database](<https://devfeed.tech/tags/database.md>), [domain-modeling](<https://devfeed.tech/tags/domain-modeling.md>), [functions](<https://devfeed.tech/tags/functions.md>), [git](<https://devfeed.tech/tags/git.md>), [induction](<https://devfeed.tech/tags/induction.md>), [logic-for-programmers](<https://devfeed.tech/tags/logic-for-programmers.md>), [math](<https://devfeed.tech/tags/math.md>), [migrations](<https://devfeed.tech/tags/migrations.md>), [release-notes](<https://devfeed.tech/tags/release-notes.md>), [specification](<https://devfeed.tech/tags/specification.md>), [testing](<https://devfeed.tech/tags/testing.md>), [type-theory](<https://devfeed.tech/tags/type-theory.md>)

### AI overview

Logic for Programmers v0.13 is over 50,000 words, about 20% larger than v0.12, and the author says every chapter has been rewritten. The Alloy chapter now presents Alloy as a domain modeling tool, so the book no longer covers data modeling. The revision connects topics across chapters and highlights themes including expressiveness versus guarantees and a provisional idea of "compatibility" linking subtyping, database migrations, backward-compatible APIs, and specification refinement. New material includes structural and metamorphic testing properties, induction and recursive-function proofs, and answer set programming. The author considers the content complete for now, has sent the manuscript to a copy editor, and still needs a technical reviewer and proofreader before layout work. The excerpt notes that topics such as proper data modeling, data structures, type theory, and model-based testing remain desired additions.

### Source excerpt

It's taken four months, but the next release of Logic for Programmers is now available! v0.13 is over 50,000 words, making it both 20% larger than v0.12 and officially the longest thing I have ever written.1 Full release notes are here, but I'll talk a bit about the biggest changes. For one, every chapter has been rewritten. Every single one. They span from relatively minor changes to complete chapter rewrites. After some rough git diffing, I think I deleted about 11,000 words?2 The biggest change is probably to the Alloy chapter. After many sleepless nights, I realized the right approach wasn't to teach Alloy as a data modeling tool but to teach it as a domain modeling tool. Which technically means the book no longer covers data modeling. There's also a lot more connections between the chapters. The introductory math chapter, for example, foreshadows how each bit of math will be used in the future techniques. I also put more emphasis on the general "themes" like the expressiveness-guarantees tradeoff (working title). One theme I'm really excited about is compatibility (extremely working title). It turns out that the Liskov substitution principle/subtyping in general, database migrations, backwards-compatible API changes, and specification refinement all follow basically the same general principles. I'm calling this "compatibility" for now but prolly need a better name. Finally, there's just a lot more new topics in the various chapters. Testing properly covers structural and metamorphic properties. Proofs covers proof by induction and proving recursive functions (in an exercise). Logic Programming now finally has a section on answer set programming. You get the picture. Next Steps There's a lot I still want to add to the book: proper data modeling, data structures, type theory, model-based testing, etc. But I've added new material for two year, and if I keep going it will never get done. So with this release, all the content is in! Just like all the content was in

## Refinement without Specification

DevFeed: [Refinement without Specification](<https://devfeed.tech/articles/refinement-without-specification-25504.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/refinement-without-specification/>)

Author: Hillel Wayne

Published: 2026-01-20T17:49:07Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Database](<https://devfeed.tech/topics/database.md>), [sql-database](<https://devfeed.tech/topics/sql-database.md>), [legacy systems](<https://devfeed.tech/topics/legacy-systems.md>)

Tags: [boolean](<https://devfeed.tech/tags/boolean.md>), [code](<https://devfeed.tech/tags/code.md>), [column](<https://devfeed.tech/tags/column.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [database](<https://devfeed.tech/tags/database.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [events](<https://devfeed.tech/tags/events.md>), [legacy-code](<https://devfeed.tech/tags/legacy-code.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [migrate](<https://devfeed.tech/tags/migrate.md>), [properties](<https://devfeed.tech/tags/properties.md>), [queries](<https://devfeed.tech/tags/queries.md>), [specification](<https://devfeed.tech/tags/specification.md>), [sql](<https://devfeed.tech/tags/sql.md>), [sql-database](<https://devfeed.tech/tags/sql-database.md>), [table](<https://devfeed.tech/tags/table.md>), [triggers](<https://devfeed.tech/tags/triggers.md>)

### AI overview

The excerpt shows how query changes and refinement mappings can let a database evolve while legacy code continues to receive equivalent results: a non-nullable activation boolean can map to a nullable timestamp, then to an event-sourced activation state. It qualifies the claim that these changes preserve external properties: refinement depends on the properties being preserved. A mutability constraint that prevents activated users from becoming deactivated can hold for the timestamp representation, but appending a deactivation event violates it; removing such events is one proposed fix. The excerpt then begins a further refinement case but cuts off before explaining its outcome.

### Source excerpt

Imagine we have a SQL database with a user table, and users have a non-nullable is_activated boolean column. Having read That Boolean Should Probably Be Something else, you decide to migrate it to a nullable activated_at column. You can change any of the SQL queries that read/update the user table but not any of the code that uses the results of these queries. Can we make this change in a way that preserves all external properties? Yes. If an update would set is_activated to true, instead set it to the current date. Now define the refinement mapping that takes a new_user and returns an old_user. All columns will be unchanged except is_activated, which will be f(new_user).is_activated = if new_user.activated_at == NULL then FALSE else TRUE Now new code can use new_user directly while legacy code can use f(new_user) instead, which will behave indistinguishably from the old_user. A little more time passes and you decide to switch to an event sourcing-like model. So instead of an activated_at column, you have a user_events table, where every record is (user_id, timestamp, event). So adding an activate event will activate the user, adding a deactivate event will deactivate the user. Once again, we can update the queries but not any of the code that uses the results of these queries. Can we make a change that preserves all external properties? Yes. If an update would change is_activated, instead have it add an appropriate record to the event table. Now, define the refinement mapping that takes newer_user and returns new_user. The activated_at field will be computed like this: g(newer_user).activated_at = # last_activated_event let lae = newer_user.events .filter(event = "activate" | "deactivate") .last, in if lae.event == "activate" then lae.timestamp else NULL Now new code can use newer_user directly while old code can use g(newer_user) and the really old code can use f(g(newer_user)). Mutability constraints I said "these preserve all external properties" and that was a

[Next page](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md?cursor=WyIyMDI2LTAxLTIwVDE3OjQ5OjA3KzAwOjAwIiwgIjI5ODcxM2Q2LTU0ZDItNDc3My1hNDU0LWJjYzg3ZDYwOTM0YiJd>)