A person watching over my shoulder asked “How are you switching around so fast?” and I realized that while most readers here know this trick, some may not, and it’s awfully useful.

[Update: I published an earlier version of this in 2012 but have got that “How do you” question a couple times recently, so maybe it’ll still be new news to a few people.]

In all the browers I use, Command-1 takes you to your leftmost tab, command-2 to the next one over, and so on up to Command-8. Command-9 selects the rightmost tab. Also, you can right-click on a tab and “pin” it; which shrinks it down to just the favicon, and moves it as far left as it can go.

So the trick is, pin the same heavily-used tabs in the same place, and leave them there forever. In my main browser (currently Safari) it’s like this:

1. SMS/RCS texts, linked to my Pixel. This is a Google thing, not sure if you need to be on Android for it to work. But for those serious conversations that remain in text-land, it’s awfully nice when you can resort to an actual keyboard.

2. Calendar.

3. Mastodon (CoSocial via the Phanpy client).

4. The local staging version of this blog, where I review and edit articles.

5. What you are now reading.

6. Blog comment review/approval.

7. Quamina (probably moving to Codeberg soon).

8. Bluesky; but it seems I never go there any more unless I’m following links from elsewhere. To be honest, not sure what I’d replace it with.

Have fun!

War is bad. Don’t start one. But we’re already in a class war and we’re losing. Where by “we” I mean most people; the winning side comprises, roughly, the richest 0.1% of the population, who are morphing into a hereditary aristocracy. [I mean that, see below.] So, what to do in a war one didn’t choose?

How bad is it?

It’s really bad, and getting worse fast. I recommend cruising through Wikipedia’s excellent article on Distribution of wealth; maybe jump straight to the Wealth inequality section. I’ve pulled one helpful graph, sourced from Oxfam, into the margin. The article has loads of other statements of the form “The richest X compared to the poorest Y have Z times️ as much.” The values of X, Y, and Z are uniformly saddening.

As a resident of a wealthy West-Coast New-World city, the effects of pathological inequality are in my face every day: Bentleys gleaming on the road, ragged people huddled in the rain cadging cash outside the drugstores, thousands homeless.

Why is that bad?

It’s not only sinful by any sane definition of sin, but stupid, inefficient, and damaging. I turn once again to Wikipedia: Effects of economic equality. I’ll add one pointer to an effect that is less obvious: It exacerbates the unaffordability crisis.

One effect of the increasing imbalance between the ultra-wealthy and everyone else is the emergence of, effectively, a hereditary aristocracy. “Wait!” you exclaim, “How about high income-tax rates for the wealthy, and inheritance taxes?” You might well ask. It turns out those are no longer operative. I’ll get into details about that, but first…

A parable: Grant Gustavson

I am, as previously related (see Southsiders and Fútbol Joy) a fan of the Vancouver Whitecaps Football Club (VWFC) who play in Major League Soccer. It’s affordable, light-hearted, high-drama, high-quality entertainment and has lifted my spirits notably in the recent dark years.

However, it appears that Vancouver’s about to lose the Whitecaps, at the whim of a Vegas-based purchaser, of whom The Athletic writes:

The potential buyer is Grant Gustavson, the son of Kentucky billionaire Tamara Gustavson and grandson of B. Wayne Hughes, founder of Public Storage, according to multiple sources with knowledge of the discussions. Forbes estimates Tamara Gustavson’s net worth at $8.5 billion.

Gustavson, 30, lives in Las Vegas. A graduate of the University of Southern California, he has been involved with the athletic department at his alma mater and helped to develop the Name, Image and Likeness (NIL) program there. He continues to work with the USC basketball program and is also involved in the management of his family’s farm, “the country’s premier thoroughbred farm with decades of storied champions throughout the stables.”

So this fucking youngster, who has life experience working at the gym at USC (where his Mom’s on the Board of Trustees) and helping out at the family farm, can reach out his mighty hand and snatch away a popular pleasure from another nation. Droit du seigneur in action.

Staying rich

I highly, highly recommend Our Tax System Should Make You Furious from the NYT. By “our” they mean America’s. First, it addresses the canard that the tax system is actually progressive; people who like things the way they are like to say “Forty percent of people pay no federal income taxes, and then the top 1 percent pay 40 percent of the income taxes.” (Tl;dr: Somewhere between highly misleading and a big fat lie.)

Second, it explains the mechanisms by which generational wealth is accumulated and preserved, effectively in perpetuity. People like Bezos and Musk pay basically no income tax, and the way they do it isn’t complicated or hard to understand.

There is actually a family of financial products called Dynasty Trusts. The first ad that popped up in response to my Web search had the marketing copy “Dynasty trusts: preserving family assets for future generations”. Or, put another way, “Dynasty trusts: Starving beggars in your neighborhood.”

Revenue from the rich

So what can we do about it? Tax expert Ray Madoff, the interviewee in the “Should Make You Furious” piece, has smart things to say. Then there’s Thomas Piketty: “Opponents of the tax on the ultra-wealthy lack historical perspective”.

The common thread is taxation of wealth not income, because the arcane abstractions of accounting make income too easy to hide. The argument is that a wealth tax of say 2%/year, starting at a threshold of a few tens of millions, won’t impair the lifestyles of the seriously wealthy, but still yield systemically important public-sector revenue

Also worth reading, from the International Monetary Fund: Game-Changers and Whistle-Blowers: Taxing Wealth. Among other things, it reports that the proportion of wealth that is hidden in one offshore tax shelter or another is pretty small, ranging from 8% in the developed countries up to 30% in poor nations. Apparently it’s harder to hide wealth than income.

Good karma

If wealth taxation won’t touch wealthy lifestyles and will help build a safer, calmer, happier society, it feels sort of irrational to oppose it. And some of the wealthy don’t. My favorite example of this is Avi Bryant. Check out I’m a Millionaire. Tax Me More, Please and Meet a millionaire who wants Canada to tax the rich. [Disclosure: I made a nice little chunk of money when my tiny investment in Avi’s startup turned into pre-IPO Twitter shares.] I’m also interested in Patriotic Millionaires, which Avi founded.

Also worth checking out: Jeff Atwood’s Stay Gold, America and Launching The Rural Guaranteed Minimum Income Initiative. So, not all of the 0.1% are The Enemy.

It’s not complicated

Around the world, governments are running up huge debts and cutting back social programs because the taxation revenue doesn’t come near the amount it requires to provide a livable society. So the choice is stark: Cut and slash deeper (read: starving beggars) or find more money. There’s lots of money out there basically just playing financial games; it needs to be put to work doing something useful.

This package of ideas should be easy to sell to voters. Of course, resistance will be ferocious and extremely well-funded. But the currently-winning side in our class war is actually a soft target. Target for what weapon, you ask? Democracy. No need for tumbrils and guillotines. Yet.

That’s James S.A. Corey, which is to say Daniel Abraham and Ty Franck, and their new series The Captive’s War, an in-progress work comprising 2¼ or so novels. The Coreys are of course best-known for their deservedly wildly popular The Expanse series and the subsequent success of the streaming-video version. The new series is… different. If you’re wondering whether or not you should wade in, the following is for you.

Minor and meta spoilers

Don’t worry, you can go on reading this even if you plan to read the books. Here’s a spoiler that has appeared in every public mention of the book, which I’ll give away with a quote from page 102: “I think some important scientific questions have finally been answered. Alien life exists, and they are assholes.” Which is to say, it doesn’t go well for the humans.

Now for the meta-spoilers. The novels are The Mercy of Gods and The Faith of Beasts, then there’s a novella, Livesuit. I found The Mercy of Gods a bit of a grind, and if that’s all I’d read I would have been pretty negative about this project. There is a major, major reveal partway into The Faith of Beasts that changed my whole outlook on the series; it makes the storytelling velocity really pick up. It’s a little annoying that Livesuit was published between the two full novels because it only really makes sense if you’ve finished both of them. So do like I did, and read the novella last.

I have to ask why the Coreys couldn’t have pulled the curtain aside a little earlier on. And while I’m griping, let me add that the sped-up storytelling runs into a big honking cliffhanger ending at high velocity. Harumph.

My take-away

It could go off the rails but if they can maintain their Expanse form, I suspect this series is going to be pretty great. The characters are fun to know and the narrative revolves around the great mother of all trolley-problem ethical challenges, which was not nearly resolved at cliffhanger-ending time.

Those of us who are fussy about the plausibility of future technologies (hey, Charlie Stross) should avert their eyes from the Coreys’ fairly low-effort attempts to explain how the aliens and humans in this story accomplish the things they do. Doesn’t bother me much, though.

Having said all that, this series is not cheerful stuff; I do not recommend it to those who, like many in these troubled times, are having trouble seeing the bright side of, well, anything.

Will I read the next volume?

Yep, no hesitation. And they’ve already started working on a streaming version. Unfortunately it’s going to be on Amazon Prime, which I haven’t missed since unsubscribing a couple years ago. Getting this thing on the screen is going to be an extended, difficult, task. There are multiple species of aliens that the show is going to have to absolutely nail, with emotional credibility, for the story to work. Don’t hold your breath.

On impulse, Lauren and I went out for a short walk — around just a few blocks — as the grey Spring afternoon shaded to dusk. On a second impulse, I grabbed the camera on the way out the door.

In our local community garden, here’s (I think) a chard.

That was in Vancouver’s Mount Pleasant park, small but nice and apparently never not used. Also this old blackened fruit tree, we’re a bit past the fruit-blossom peak for this year. Nice to see I’m not the only old citizen trying to brighten things up.

Now we’re walking up a locally-main street called Main Street or “The Main” if you’re trying to sound hip. Someone put work into that window! I’ve bought my daughter a couple of cool birthday presents from the store behind it. My thanks to the building across the street for providing a dark background reflection.

Back to the next block over from ours. A while ago a bunch of people were building little fairy/elf/hobbit villages at the bottoms of the big old trees. This isn’t that. What is it?

The colors of the natural surfaces are real.

Cameras

When I shot these, it was getting dark but I didn’t think much, mostly just pointed and shot. (Fiddled with the aperture dial a bit.) Then I came home and pulled them into Lightroom and didn’t need to do really anything about colors. A bit of contrast and highlights here and there. Oh, and fairly brutal cropping, especially on that fruit-tree-flowers pic. Because like I said, I didn’t think very much when I was shooting and I didn’t have to because on a Twenties camera you don’t.

I could take that heavily-cropped fruit-tree picture and print it big enough to occupy any domestic wall in your place and yeah, there’d be grain but it wouldn’t bother your eyes.

Anyhow, modern cameras are pretty great. The lowest ISO in today’s set is 2500 and the highest is 6400; the apertures range from 2.8 to 5.6. Bet you can’t tell the differences. My camera is a reasonably modern Fujifilm but not remotely bleeding-edge in camera tech. (Note: 35mm F1.4, now all the Fuji fanfolk are smiling and nodding.)

Anyhow, there are very very few photographers for whom the camera they carry is the limiting factor in the goodness of their pictures. Certainly not me.

Consider getting a camera. Used is fine, anything built in the last five years, maybe more, will effortlessly take brilliant pictures in almost any conditions. Sure, your phone can take great shots too, but the feeling of walking along with something that fits your hand and you only have to press one physical button once, that feeling, it helps you see the good pictures when they happen.

Then go out after and take a walk in the Spring dusk.

What happened was, soon after New Year’s, friends and colleagues in the UK and Germany started letting us know that their emails to us were bouncing. Our “textuality.com” family domain is a Google Workspace (or whatever they call it this year) for email and docs and so on. Its Web presence, including DNS, has for many years been handled by a local outfit I’ll call “CWH” for some absurdly low monthly price, and has been trouble-free.

So, what could be wrong? We investigated and discovered that Google was offering a new-and-improved MX-record option, although they emphasized that the old setup should still work. Anyhow, we installed the New Thing and it didn’t help.

So, we filed a ticket with CWH tech support and somebody got back to us pretty quick, saying they’d changed a firewall setting that was blocking connections to Germany. I detect the scent of GDPR, but whatever.
Euro-email: Bounce, bounce.

CWH: Probably an MX-record issue, and we should wait for DNS propagation. Several days passed and bounce, bounce, bounce.
Us: “Not DNS propagation.”
CWH: “Still could be.”

So we VPN’ed to Germany and discovered we couldn’t ping Textuality’s IP address. Smells like a firewall to me. We told CWH that.

CWH: We have made some changes to firewall settings.
EMail: bounce, bounce, bounce.
VPN+Ping: Request timeout, request timeout, request timeout.

CWH: Try traceroute?
VPN+Traceroute: 14 hops, no joy.

CWH: Your VPN settings must be wrong. Here are instructions to use Windows PC VPN correctly.
Us: Thanks but no.

CWH: Your MX records are configured incorrectly.
Us: No, they are correct per Google guidance. We sent an email beginning “Please believe us.”

CWH: It must be DNSSEC. Check to see if your registrar implements DNSSEC.
Us: We are using your DNS servers.

CWH: Perhaps your registrar is broadcasting an old record?
Us: Our registrar doesn’t do DNSSEC.

At this point we consulted a friend who’s an expert on DNS and Email and even DNSSEC. He verified that not only could you not ping Textuality from Germany, you also couldn’t ping CWH or its name servers. Firewall firewall firewall!

CWH: “I did test the site access using a 3rd party application, and it seems to be accessible on all parts.”
Us: Look at the output, it shows we can’t be reached from anywhere in Germany.

Also, for all the remaining messages in the email trail, we prefixed our input with bold face extra-large text reading: Systems located in Germany cannot ping Textuality.com’s IP address, nor can they ping the IP addresses of textuality.com’s designated name servers. This is the problem.

CWH: Let’s try migrating you to a different server; try pinging these hostnames.
VPN+Ping: Nope.

CWH: Are you sure it’s not your VPN settings?
Us: Are you sure it’s not your GDPR settings?
CWH: Raising your issue to Tier 3.

20 hours pass, then we get email from:

Nash Burns!

…who said “This has been fixed.” It was. Nash’s email signature was “Nash(Rajaneesh) B”. What a great name, though. Thanks, Nash.

Am we mad?

Not really. Consumer-facing tech support is hard. None of their suggestions were unreasonable. Doing GDPR correctly is hard. They’ve been just fine for years and were having a bad week. Could we expect better from any of CWH’s local competitors? Probably not.

It wasn’t funny at the time, but looking back, it kind of is.

This last weekend we attended a concert entitled Lenten Reflection at Vancouver’s Catholic Holy Rosary Cathedral featuring the Belle Voci vocal group and the Cantare Super Orchestram early-music band. The music was fine and it was the most beautiful sound I’ve heard in a long time. Twenty-two months, to be precise (see below). And so I get to report on good music and yell at production people.

A cathedral is a nice place for a concert!

The concert opened with just the singers, their voices drifting down from a high place behind us, a balcony or choir loft. There was no incremental accompaniment and no amplification; the music flowed from vocal cords to eardrums — not directly, of course, there was lots of reflection and reverberation introduced by the Cathedral space. The singers were polished and expressive and the sound, drifting through the vast space, beyond exquisite.

They sang a lovely piece by Byrd (1539-1623). Then the instrumentalists played a number by von Biber (1644-1704) while the singers snuck downstairs. Joined, they performed Bach’s BWV 229 and 150, then pieces by Pergolesi (1710-1736) and Steffani (1654-1728).

The Bach pieces, as usual, had more music in the music, but the others were also fun. It was a small ensemble: In the choir, five sopranos, five altos, a countertenor, four each tenors and basses. The band had five baroque violins, a baroque viola, a baroque cello, a violone (think, string bass with frets), a baroque bassoon, and a player doubling on harpsichord and organ. Thus, an ensemble quite likely not too much bigger or smaller than the ones playing this music in the 1700s, when it was new.

That sound

Once again, the sound was something special and yeah, the musicians were excellent, but for me, the key thing was the lack of amplification: vocal cord to eardrum via cathedral. It’s always seemed obvious to me that you can’t run music through a bunch of electronics and speaker mechanics without changing it; if only spatially, with the sounds coming from speaker diaphragms located somewhere away from the human musician. To my ears, there is a fragile magic in pure unamplified sound. I lack the words to describe the difference but it’s not subtle.

Does this mean that everything was perfect? No; the choir was a little bit male-heavy; some of the soprano and especially alto lines were part-hidden behind the massed male voices. Also, the bassoon was right at the front of the stage; While the playing was fine, it felt as though it were musically, not just physically “in front of” the band and singers.

Both of these could have been fixed, by telling the men to take it down a notch or having one or two fewer of them. And by moving the bassoon back to the usual woodwinds spot behind the strings. Still, these were very minor imperfections.

Oh, and the performance and sound of the bass line on that violone was absolutely awesome; clearly audible as a thing on its own while it wove all the other musical threads together.

I’ve discovered that few classical musicians share my passion for unamplification. I hear things like “I want a full sound or “The soloists need to cut through the orchestra.” Which, well, OK, but somehow people managed to accomplish those things for centuries, before amplifiers and speakers were invented.

22 months?

That’s since May of 2024 when I took in the Tedeschi-Trucks Band, whose music couldn’t be more different from anything called “Lenten Reflections”: electric not acoustic, profane not sacred. But crystal clear and perfectly balanced sound; so much better than most electric bands achieve.

My sincere thanks to the musicians and their leaders for a lovely experience. And my message to everyone co-ordinating and leading live music performances: Of course the first priority has to be the quality of the music, but think about the sound and try to be better. Better than than most performances manage, these days.

We know it’s possible.

Block announced that it’s cutting 40% of its workforce. It didn’t say it was replacing those people with GenAI. Not out loud. Jack Dorsey did say “I believe the majority of companies will reach the same conclusion and make similar structural changes.” Wall Street loved it, bidding up the share price by 24%. Which reminded me of Kansas in 2010.

The Kansas Experiment

As long as I can remember, a certain class of right-wing evangelists has preached that cutting taxes would stimulate business growth and everyone would come out ahead. There are a couple of problems with this theory. First, mainstream economists almost universally think it’s just wrong. Second, most of the people pushing it are rich and would benefit from the cuts.

Anyhow, in 2010 US Senator Sam Brownback won the race for governor of Kansas on what was then called the “Tea Party” program: Prosperity through tax cuts. Tea-party Republicans also won a large majority in the state legislature. Unsurprisingly they immediately did what they said they were going to do: Slashed a wide variety of taxes, some to zero.

The predicted prosperity failed to happen. The state government’s revenue plunged and it had to dig deep into rainy-day reserves just to keep the doors open. There were brutal cuts to policing, road repair, and schools. Also a nasty feedback loop: As the state’s fiscal position worsened, its credit rating fell and interest rates rose, leading to yet more brutal austerity measures.

Another result was that affluent Kansans made out like bandits; the cost of running the state was substantially transferred to the less financially fortunate.

In 2017, the legislature threw in their cards and repealed the tax cuts, overriding Brownback’s veto.

While this was a terrible experience for most Kansans, it is historically useful, because whenever you encounter a tax-cut nut (probably self-interestedly wealthy) you can say “But, Kansas!” Having said that, there are still plenty of those nuts, and they’ll tell you that the Kansas experiment failed because of one fine-tuning effort or another. That’s a position that’s hard to defend, though.

Sidebar: Trans oppression too

Before I move onto the AI angle, I gotta pause to acknowledge this week’s news story about the Kansas government’s vicious, brutal, and ignorant assault on trans people. To be clear, I think the shitty people who hate trans folk are aren’t necessarily the same shitty people as the shitty people who don’t want to contribute to the public good. But, something about Kansas seems to attract both flavors.

The GenAI experiment

The core value proposition of contemporary AI technology is exactly what Dorsey seems to think: Fire half your employees and profits will soar! If that’s true, the trillion dollars or so invested so far will seem like small potatoes. Since we don’t know if this will actually work, anyone who actually does it is conducting an experiment. Just like Sam Brownback did. Unsurprisingly, the investor class loves this experiment and is putting their money on it working.

To be fair, voices have been raised to argue that the tech sector is a special case: That following on feverish over-hiring during the Covid lockdown, they need to slash headcount anyhow, and are using AI as an excuse. For example John Gruber.

I personally am unconvinced, but even if they’re right, it’s irrelevant. The shareholding class won’t be able to see past that 24% payoff. So as of today, they’ll be yelling at every CEO on the planet to start pulling the mass-firing trigger. Or else.

I think I know how the experiment will turn out. Just like in Kansas, it’s not going to be fun.

I’ve run early-spring pictures of these little purple guys almost every year since this blog’s birth in early 2003. Except for last year. Because we moved and the new place didn’t have any. Only now it does, and they’re (just barely) up. [Update: Up and open, too.]

Long-time followers may note that they’re pale and fragile compared to the exuberant blossoms of previous years. Not sure why, but our new place faces north and there’s this enormous White Ash tree right in front of it, so they’re not getting as much sun as at the south-facing former joint.

And also this is their first spring. We bought the bulbs and hired a professional with the right tools to jam them into the earth last autumn, between the big tree’s roots. So they really haven’t had a chance to get their own root systems going.

And finally, it really is the first day that’s bright and warm enough to get out the camera. Maybe they’ll be better in another few days. And quite likely next Spring.

This would be the place to introduce whatever metaphor this year’s blossoms, fighting their way through the leaf cover in chilly air toward the sun, fit into, but I’m not gonna.

I, like many, am not dealing very well with what I see when I look at the world in either the big or the ultra-local landscapes. The world in tough shape and its worst people are making it worse. People I love are in ugly corners and not finding help.

But you know, the flowers, in their low-key way, look great and so does the tree, still in wintersleep. Today the sun was shining on them. It’ll be warmer and nicer soon.

Metaphors can go to hell. It’s just late-winter light on pale violet petals. Enjoy the moments you have with it.

I’ve been puttering away on my Quamina project since 2023. In the last few weeks GenAI has intervened. Quamina + Claude, Case 1 describes a series of Claude-generated human-curated PRs, most of which I’ve now approved and merged. Quamina + Claude, Case 2 considers quamina-rs, a largely-Claude-driven port from Go to Rust. Both of these stories seem to have happy endings and negligible downsides. So empirically, I can apply LLM technology usefully to software development. But should I?

Conclusions 1: Burn it with fire?

Let me be clear: In the big GenAI picture, I’m a contra. Why? I’ll pass the mike to Baldur Bjarnason, my favorite among GenAI’s blood enemies.: “AI” is a dick move. His tl;dr is something like “GenAI is environmentally devastating and has the goal of throwing millions of knowledge workers onto the street and is being sold by the worst people and is used for horrible applications and will increase society’s already-intolerable level of inequality!” To which I reply “Yes, yes, yes, yes, and yes.”

At the end of the day, the business goal of GenAI is to boost monopolist profits by eliminating decent jobs, and damn the consequences. This is a horrifying prospect (although I’m somewhat comforted by my belief that it basically won’t work and most of the investment capital is heading straight down the toilet).

But. All that granted, there’s a plausible case, specifically in software development, for exempting LLMs from this loathing.

First of all, size. JetBrains thinks that the world has 21 million or so software developers, i.e. less than 1% of the earth’s working population. Vanishingly small in the context of the lunatic tsumani of LLM overinvestment. Training and operating the models required for a market this small is rounding error measured on the Great GenAI Overbuild scale. There aren’t enough geeks to create a detectable bump in the global carbon load.

Another odious aspect of LLMs is RLHF, “Reinforcement Learning From Human Feedback”, which relies on underpaying Third-Worlders to polish the models’ outputs. My guess is that much less is required for code-oriented LLMs. The combination of the compiler and your unit tests provide good starter guardrails. Then skilled professional intervention is required to deal with the remaining misfires, as with those Quamina PRs.

Finally, it seems making billionaires into multibillionaires is intrinsic to GenAI dreams. But software-development tools won’t do that. Once again, the market is just too small. But even if it weren’t, consider this from Steve Yegge:

For this blog post, “Claude Code” means “Claude Code and all its identical-looking competitors”, i.e. Codex, Gemini CLI, Amp, Amazon Q-developer ClI, blah blah, because that’s what they are. Clones.

(GenAI, overbuilding wherever you look.) None of these products have moats and the chance that any of them become extractive monopolies is about zilch. Nobody’s ever built a major cash-cow on developer tooling

One reason is (*gasp*) Open Source. Does anybody doubt that in the near future, there will be entirely open-source versions of what Yegge means by “Claude”?

So, if you want to condemn the use of GenAI in software development, I think you need arguments other than the fact that it’s also being promoted for societally-toxic business purposes.

I have a few. But stand by, let me push that on the stack and turn to technology for a bit.

Conclusions 2: Engineering sanity?

Question: Can LLMs even participate in quality software engineering? Baldur doesn’t think so: “The gigantic, impossible to review, pull requests. Commits that are all over the place. Tests that don’t test anything. Dependencies that import literal malware. Undergraduate-level security issues. Incredibly verbose documentation completely disconnected from reality.”

I’m not saying that these pathologies can’t or don’t happen. But in my personal experience with Quamina, they didn’t. (Mind you, it’s a hobby project.)

And when they do happen, I would assume that mature open-source projects will use a network of trust, as big operations like Linux already do. PRs that don’t have the imprimatur of someone known to be clueful will be ignored. When I saw the first of those incoming Quamina PRs, I took the time for a serious look because I knew Rob and had seen evidence that he was technically competent. If I see an incoming PR that’s nontrivial and from some rando and doesn’t pass a 120-second sanity check, it’s unlikely to get any more attention.

In fact, some essentials don’t change. If you’re not requiring that PRs be clean and test coverage be good and code reviews not be skipped and dependencies be curated, you’re going to get a lousy result whether the upstream code is coming from a human or an LLM.

But it’d be naive to think that a big change in the shape of that upstream isn’t going to affect the profession.

Bottlenecks

Speaking from personal experience, reviewing the PRs from Claude&Rob was neither faster nor slower, easier nor harder, than what I’m used to pre-GenAI. The number of my disagreements with the diffs, and the amount of arguing it took to resolve them, was also about as usual. Which creates a big problem. Because if we can generate code a whole lot faster but review doesn’t speed up, all we’ve done is moved the bottleneck in the system.

Speaking of which, Armin Ronacher offers The Final Bottleneck, from which: “When one part of the pipeline becomes dramatically faster, you need to throttle input.” Think about that.

Burnout

Meanwhile, evidence is piling up that LLM-based software development is driving developers to overwork and burnout. Here’s a cool-eyed take from Harvard Business Review. Then there’s Steve Yegge’s frantic, overly-long The AI Vampire. But my favorite, and I think a must-read, is Siddhant Khare’s AI fatigue is real and nobody talks about it. From which: “AI reduces the cost of production but increases the cost of coordination, review, and decision-making. And those costs fall entirely on the human.”

The argument we’re hearing is that GenAI makes development more efficient. And more efficient is better. Until it’s not.

I’m not sure the profession I joined last century would attract me today. And on Mastodon, @GordWait said “At our office, we are noticing a huge drop in Comp Sci co-op applications. The next generation is convinced there’s no future in programming thanks to AI hype.”

Can and should

Here’s another conundrum. Suppose we can build a whole lot more stuff, faster. Should we? I don’t know about you, but I am regularly enraged at tools that work just fine popping up “wonderful new features” modals in front of what I’m trying to get accomplished. Also at damaging UI churn, driven by product managers trying to get promoted. It’s just not obvious that speeding up software development is, in the big picture, a good thing.

And I can’t help noting that every attempt to measure the productivity boost due to GenAI has shown zero (or worse) improvement. Of course, Claude’s cheering section will point out that those studies date to 2024 which is the stone age. Maybe they’re right.

Vampires

(In which I once again go all class-reductionist.) The real problem here is late-stage capitalism, and I think is best addressed in Yegge’s AI Vampires piece, from which I quote: “…dollar-signs appear in their [employers’] eyeballs, like cartoon bosses. I know that look. There’s no reasoning with the dollar-eyeball stare.” Yeah.

Thus the ancient question: cui bono? Assuming GenAI genuinely boosts productivity, who gets the benefits? Because the ownership class sure doesn’t think they should go to their newly-more-efficient employees.

But, what do I know?

I know that you gotta have test coverage or your software is an unmaintainable tangle of festering tech debt. I know you gotta have code review or your quality is on inexorable downhill drift. I don’t know how to build LLMs into a sane, sustainable software engineering culture. Nor what to do about capitalism’s AI Vampires.

And I absolutely do not believe the wild-eyed claims of 10× productivity gains, assuming we demand (as we should) that they’re sustainable at scale.

So, would I advise executives to tell software engineering shops to discard their culture in favor of vibe coding in the expectation of monstrous productivity wins? Nope. Vibe engineering, maybe. Centaurs, not reverse centaurs? Indeed.

But would I say “Stay away, don’t even look”? Nope. I’d probably suggest pointing the LLM at well-delimited non-strategic issues and optimizations, and emphasize no shortcuts on reviewing or CI/CD standards.

Also note that the GenAI apostles are at one in saying that this year’s tools are so much better than last year’s, and next year’s are guaranteed to be qualitatively still better! So why would you rush in and risk getting locked into soon-to-be-outmoded tooling?

Rob Sayre wrote “I would never bother to type out these patches by hand. But I read them all.” I probably wouldn’t have either and I read them too. And now Quamina is roughly twice as fast. Which is to say, I got good results on a hobby project. That’s not nothing.

But, also not conclusive. Once the AI bubble pops and we’ve recovered from the systemic damage, I think there’ll probably be a place for open-source LLM automation in developer toolkits.

But maybe not. Wouldn’t surprise me much, either way.

There’ve been a few bugfixes and optimizations since 1.5, but the headline is: Quamina now knows regular expressions. This is roughly the fourth anniversary of the first check-in and the third of v1.0.0. (But I’ve been distracted by family health issues and other tech enthusiasms.) Open-source software, it’s a damn fine hobby.

Did I mention optimizations? There are (sob) also regressions; introducing REs had measurable negative impacts on other parts of the system. But it’s a good trade-off. When you ship software that’s designed for pattern-matching, it should really do REs. The RE story, about a year long, can be read starting here.

Quamina facts

1. About 18K lines of code (excluding generated code), 12K of which are unit tests. The RE feature makes the tests run slower, which is annoying.

2. Adding Quamina to your app will bulk your executable size up by about 100K, largely due to Unicode tables.

3. There are a few shreds of AI-assisted code, none of much importance.

4. A Quamina instance can match incoming data records on my 2023 M2 Mac at millions per second without much dependence on how many patterns are being matched at once. This assumes not too many horrible regular expressions. That’s per-thread of course, and Quamina does multithreading nicely.

Next?

The open issues are modest in number but some of them will be hard.

I think I’m going to ignore that list for a while (PRs welcome, of course) and work on optimization. The introduction of epsilon transitions was required for regular expressions, but they really bog the matching process down. At Quamina’s core is the finite-automaton merge logic, which contains fairly elegant code but generally throws up its hands when confronted with epsilons and does the simplest thing that could possibly work. Sometimes at an annoyingly slow pace.

Having said that, to optimize you need a good benchmark that pressures the software-under-test. Which is tricky, because Quamina is so fast that it’s hard to to feed it enough data to stress it without the feed-the-data code dominating the runtime and memory use. If anybody has a bright idea for how to pull together a good benchmark I’d love to hear it. I’m looking at b.Loop() in Go 1.24, any reason not to go there?

Book?

It occurs to me that as I’ve wrestled with the hard parts of Quamina, I’ve done the obvious thing and trawled the Web for narratives and advice. And, more or less, been disappointed. Yes, there are many lectures and blogs and so on about this or that aspect of finite automata, but they tend to be mathemagical and theoretical and say little about how, practically speaking, you’d write code to do what they’re talking about.

The Quamina-diary ongoing posts now contain several tens of thousands of words. Also I’ve previously written quite a bit about Lark, the world’s first XML parser, which I wrote and was automaton-based. So I think there’s a case for a slim volume entitled something like Finite-state Automata in the Code Trenches. It’d be a big money-maker, I betcha. I mean, when Apple TV brings it to the screen.

Why?

Let’s be honest. While the repo has quite a few stars, I truly have no idea who’s using Quamina in production. So I can’t honestly claim that this work is making the world better along any measurable dimension.

I don’t much care because I just can’t help it. I love executable abstractions for their own sake.

Confession: My title is clickbait-y, this is really about building on the Unicode Character Database to support character-property regexp features in Quamina. Just halfway there, I’d already got to 775K lines of generated code so I abandoned that particular approach. Thus, this is about (among other things) avoiding those 1½M lines. And really only of interest to people whose pedantry includes some combination of Unicode, Go programming, and automaton wrangling. Oh, and GenAI, which (*gasp*) I think I should maybe have used.

Character property matching

I’m talking about regexp incantations like [\p{L}\p{Zs}\p{Nd}], which matches anything that Unicode classifies as a letter, a space, or a decimal number. (Of course, in Quamina “\” is “~” for excellent reasons, so that reads [~p{L}~p{Zs}~p{Nd}].)

(I’m writing about this now because I just launched a PR to enable this feature. Just one more to go before I can release a new version of Quamina with full regexp support, yay.)

Finding the properties

To build an automaton that matches something like that, you have to find out what the character properties are. This information comes from the Unicode Character Database, helpfully provided online by the Unicode consortium. Of course, most programming languages have libraries that will help you out, and that includes Go, but I didn’t use it.

Unfortunately, Go’s library doesn’t get updated every time Unicode does. As of now, January 2026, it’s still stuck at Unicode 15.0.0, which dates to September 2023; the latest version is 17.0.0, last September. Which means there are plenty of Unicode characters Go doesn’t know about, and I didn’t want Quamina to settle for that.

So, I fetched and parsed the famous master file from www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt. Not exactly rocket science, it’s a flat file with ;-delimited fields, of which I only cared about the first and third. There are some funky bits, such as the pair of nonstandard lines indicating that the Han characters occur between U+4E00 and U+9FFF inclusive; but still not really taxing.

The output is, for each Unicode category, and also for each category’s complement (~P{L} matches everything that’s not a letter; note the capital P), a list of pairs of code points, each pair indicating a subset of the code space where that category applies. For example, here’s the first line of character pairs with category C.

    {0x0020, 0x007e}, {0x00a0, 0x00ac}, {0x00ae, 0x0377},

How many pairs of characters, you might wonder? There are 37 categories and it’s all over the place but adds up to a lot. The top three categories are L with 1,945 pairs, Ll at 664, and M at 563. At the other end are Zl and Zp, both with just 1. The total number of pairs is 14,811, and the generated Go code is a mere 5,122 lines.

Character-property automata

Turning these creations into finite automata was straightforward: I already had the code to handle regexps like [a-zA-Z0-9], logically speaking the same problem. But, um, it wasn’t fast. My favorite unit test, an exercise in sample-driven development with 992 regexps, suddenly started taking multiple seconds, and my whole unit-test suite expanded from around ten seconds to over twelve; since I tend to run the unit tests every time I take a sip of coffee or scratch my head or whatever, this was painful. And it occurred to me that it would be painful in practice to people who want for some good reason or another to load up a bunch of Unicode-property patterns into a Quamina instance.

So, I said to myself, I’ll just precompute all the automata and serialize them into code. And now we get to the title of this essay; my data structure is a bit messy and ad-hoc and just for the categories, before I got to the complement versions, I was generating 775K lines of code.

Which worked! But, it was 12M in size and while Go’s runtime is fast, there was a painful pause while it absorbed those data structures on startup. Also, opening the generated file regularly caused my IDE (Goland) to crash. And I was only halfway there. The whole approach was painful to work with so I went looking for Plan B.

The code that generates the automaton from the code point pairs is pretty well the simplest thing that could possibly work and it was easy to understand but burned memory like crazy. So I worked for a bit on making it faster and cheaper, but so far have found no low-hanging fruit.

I haven’t given up on that yet. But in the meantime, I remembered Computer Science’s general solution for all performance problems, by which I mean caching. So now, any Quamina instance will compute the automaton for a Unicode property the first time it’s used, then remember it. So now Quamina’s speed at adding Unicode-property regexps to an instance has increased from 135/second to 4,330, a factor of thirty and Good Enough For Rock-n-Roll.

It’s worth pointing out that while building these automata is a heavyweight process, Quamina can use them to match input messages at its typical rates, hundreds of thousands to millions per second. Sure, these automata are “wide”, with lots of branches, but they’re also shallow, since they run on UTF-8 encoded characters whose maximum length is four and average length is much less. Most times you only have to take one or two of those many branches to match or fail.

Should I have used Claude?

This particular segment of the Quamina project included some extremely routine programming tasks, for example fetching and parsing UnicodeData.txt, computing the sets of pairs, generating Go code to serialize the automata, reorganizing source files that had become bloated and misshapen, and writing unit tests to confirm the results were correct.

Based on my own very limited experience with GenAI code, and in particular after reading Marc Brooker’s On the success of ‘natural language programming’ and Salvatore (“antirez”) Sanfilippo’s Don't fall into the anti-AI hype, I guess I’ve joined the camp that thinks this stuff is going to have a place in most developers’ toolboxes.

I think Claude could have done all that boring stuff, including acceptable unit tests, way faster than I did. And furthermore got it right the first time, which I didn’t.

So why didn’t I use Claude? Because I don’t have the tooling set up and I was impatient and didn’t want to invest the time in getting all that stuff going and improving my prompting skills. Which reminds me of all the times I’ve been trying to evangelize other developers on a better way to do things and was greeted by something along the lines of “Fine, but I’m too busy right now, I’ll just going on doing things the way I already know how to.”

Does this mean I’m joining the “GenAI is the future and our investments will pay off!” mob? Not in the slightest. I still think it’s overpriced, overhyped, and mostly ill-suited to the business applications that “thought leaders” claim for it. That word “mostly” excludes the domain of code; as I said here, “It’s pretty obvious that LLMs are better at predicting code sequences than human language.”

And, as it turns out, the domain of Developer Tools has never been a Big Business by the standards of GenAI’s promoters. Nor will it ever be; there just aren’t enough of us. Also, I suspect it’ll be reasonably easy in the near future for open-source models and agents to duplicate the capabilities of Claude and its ilk.

Speaking personally, I can’t wait for the bubble to pop.

Quamina.next?

After I ship the numeric-quantifier feature, e.g. a{2-5}, Quamina’s regexp support will be complete and if no horrid bugs pop up I’ll pretty quickly release Quamina 2.0. Regexps in pattern-matching software are a qualitative difference-maker. After that I dunno, there are lots more interesting features to add.

Unfortunately, a couple years into my Quamina work, I got distracted by life and by other projects, and ignored it. One result is that so did the other people who’d made major contributions and provided PR reviews. I miss them and it’s less fun now. We’ll see.

I’m just landing a chonky PR in Quamina whose effect is to enable the + and * regexp features. As in my last chapter, this is a disorderly war story not an essay, and probably not of general interest. But as I said then, the people who care about coercing finite automata into doing useful things at scale are My People (there are dozens of us).

2014-2026

As I write this, I’m sitting in the same couch in my Mom’s living room in Saskatchewan where, on my first Christmas after joining AWS, I got the first-ever iteration of this software to work. That embryo’s mature form is available to the world as aws/event-ruler. (Thanks, AWS!) Quamina is its direct descendent, which means this story is entering its twelfth year.

Mom is now 95 and good company despite her failing memory. I’ve also arrived at a qualitatively later stage of life than in 2014, but would like to report back from this poorly-lit and often painful landscape: Executable abstractions are still fun, even when you’re old.

Anyhow, the reason I’m writing all this stuff isn’t to expound on the nature of finite automata or regular expressions, it’s to pass on lessons from implementing them.

Lesson: Seek out samples

In a previous episode I used the phrase Sample-driven development to describe my luck in digging up 992 regexp test cases, which reduced task task from intimidating to approachable. I’ve never previously had the luxury of wading into a big software task armed with loads of test cases written by other people, and I can’t recommend it enough. Obviously you’re not always going to dig this sort of stuff up, but give it a sincere effort.

Lesson: Break up deliverables

I decomposed regular expressions into ten unique features, created an enumerated type to identify them, and implemented them by ones and twos. Several of the feature releases used techniques that turned out to be inefficient or just wrong when it came to subsequent features. But they worked, they were useful, and my errors nearly all taught me useful lessons.

Having said that, here’s some cool output that combines this lesson and the one above, from the unit test that runs those test cases. Each case has a regexp then one or more samples each of strings that should and shouldn’t match. I instrumented the test to report the usage of regexp features in the match and non-match cases.

Feature match test counts:
 32 '*' zero-or-more matcher
 27 () parenthetized group
 48 []-enclosed character-class matcher
 7 '.' single-character matcher
 29 |-separated logical alternatives
 16 '?' optional matcher
 29 '+' one-or-more matcher
 
Feature non-match test counts:
 45 '+' one-or-more matcher
 24 '*' zero-or-more matcher
 31 () parenthetized group
 49 []-enclosed character-class matcher
 6 '.' single-character matcher
 32 |-separated logical alternatives
 21 '?' optional matcher

Of course, since most of the tests combine multiple features, the numbers for all the features get bigger each time I implement a new one. Very confidence-building.

Lesson: Thompson’s construction

This is the classic nineteen-sixties regular-expression implementation by Ken Thompson, described in Wikipedia here and (for me at least) more usefully, in a storytelling style by Russ Cox, here.

On several occasions I rushed ahead and implemented a feature without checking those sources, because how hard could it be? In nearly every case, I had problems with that first cut and then after I went and consulted the oracle, I could see where I’d gone wrong and how to fix it.

So big thanks, Ken and Russ.

Lesson: List crushing

In some particularly nasty regular expressions that combine [] and ? and + and *, you can get multiple states connected in complicated ways with epsilon links.

In Thompson’s Construction, traversing an NFA transitions not just from one state to another but from a current set of states to a next set, repeat until you match or fail. You also compute epsilon closures as you go along; I’m skipping over details here. The problem was that traversing these pathologically complex regexps with a sufficiently long string was leading to an exponential explosion in the current-states and next-states sizes — not a figure of speech, I mean O(2N). And despite the usage of the word “set” above, these weren’t, they contained endless duplicates.

The best solution would be to study the traversal algorithm and improve it so it didn’t emit fountains of dupes. That would be hard. The next-best would to turn these things into actual de-duped sets, but that would require a hash table right in the middle of the traversal hot spot, and be expensive.

So what I did was to detect whenever the next-steps list got to be longer than N, sorted it, and crushed out all the dupes. As I write, N is now 500 based on running benchmarks and finding a value that makes number go down.

The reason this is good engineering is that the condition where you have to crush the list almost never happens, so in the vast majority of cases the the only cost is an if len(nextSteps)>N comparison. Some may find this approach impure, and they have a point. I would at some point like to go back and find a better upstream approach. But for now it’s still really fast in practice, so I sleep soundly.

Lesson: Hell’s benchmark

I’ve written before about my struggles with the benchmark where I merge 12,959 wildcard patterns together. Back before I was doing epsilon processing correctly, I had a kludgey implementation that could match patterns in the merged FA at typical Quamina speeds, hundreds of thousands per second. With correct epsilon general-purpose epsilon handling, I have so far not been smart enough to find a way to preserve that performance. With the full 13K patterns, Quamina matches at less than 2K/second, and with a mere thousand, at 16K/second. I spent literally days trying to get better results, but decided that it was more valuable to Quamina to handle a large subset of regular expressions correctly than to run idiotically large merges at full speed.

I’m pretty sure that given enough time and consideration, I’ll be able to make it better. Or maybe someone else who’s smarter than me can manage it.

Question: What next?

The still-unimplemented regexp features are:

{lo,hi} : occurrence-count matcher
~p{} : Unicode property matcher
~P{} : Unicode property-complement matcher
[^] : complementary character-class matcher

Now I’m wondering what to do next. [^] is pretty easy I think and is useful, also I get to invert a state-transition table. The {lo,hi} idiom shouldn’t be hard but I’ve been using regexps for longer than most of you have been alive and have never felt the need for it, thus I don’t feel much urgency. The Unicode properties I think have a good fun factor just because processing the Unicode character database tables is cool. And, I’ve used them.

[Update: the [^] thing took a grand total of a couple of hours to build and test. Hmm, what next?]

Lesson: Coding while aging

I tell people I keep working on code for the sake of preserving my mental fitness. But mostly I do it for fun. Same for writing about it. So, thanks for reading.