Hacker News Personal Blogs 2025 | All Blog Posts

2025 in review

callmeolive — Wed, 31 Dec 2025 23:30:00 GMT

Wot happened this year

2025. What a complete faff.

On the first day a Cybertruck blew up outside a Trump hotel, serving as an omen for the year to come. Nintendo announced the Switch 2, and Elon Musk performed a totally innocuous salute on stage, which just happened to be identical to a Nazi salute.

The Netflix show Adolescence took the UK by storm, bringing another year of politics via telly. The US Gov invited a journalist into a Signal chat, and Trump went bonkers with AI-generated tarriffs.

Yeah, the first year of Trump’s second term makes up a lot of this. Soz.

The Minecraft film released in April – unleashing hordes of TikTok users screaming Chicken jockey. Skype died (🦀), and now there’s an American Pope. Feels weird that there’s a pope you can speak plain English with.

Kids started fires with their Chromebooks, Leeroy Jenkins hit 20 years old, and X’s AI chatbot Grok started replying to every prompt about “white genocide” in South Africa. It’d soon go on a racist bender and call itself ‘MechaHitler’, with X’s CEO retiring a day later. At least we got a nice chuckle out of Orc City while it went down.

Also speaking of chatting AI, Fortnite players got the late James Earl Jones to say fuck.

The viral moment of the year went to Coldplay, who caught a CEO’s awkward affair live on kiss-cam.

In July the Labour party announced they’d give 16 year olds the vote, then disenfranchised them by blocking off the net with the Online Safety Act – on the bright side, myself and half the country seemingly moved to Sweden, so it’s no bother.

Remember that War of the Worlds adaptation with Ice Cube? Terrible, but hilarious. Summer tapped off with Labubu dolls and Dubai chocolate reaching peak popularity, and then Silksong finally released!

The Great North Run handed out medals with the wrong city, Trump went mental over paracetamol, and Windows 10 reached EOL.

The global Anglican church split over female bishops & LGBT rights, jewel thieves struck the Louvre, and a certain Windsor became the Andrew formerly known as Prince.

Towards the end of the year we saw a steady release of the Epstein files – overly redacted of course – and… Yeah I’m running out. Does else anyone care that the Doctor Who series 10 soundtrack finally released? Uhhh 6-7????

Notable deaths include Tony Slattery, David Lynch, Val Kilmer, Pope Francis, Kenneth Colley, Felix Baumgartner, Ozzy Osbourne, Drew Struzan, and Rebecca “Burger Becky” Heineman.

On tech and the web

Big tech & Trump

We’ve all seen the shockingly brazen integration of Big Tech and the Trump administration. After “donating” hefty sums to his campaign, all the CEOs were caught cosying up to him either buy favour against antitrust suits, or to simply avoid his furore.

Funny how Facebook removed LGBT pride themes from messenger and rolled back fact-checking a week before the inauguration, and how all these platforms now call it “The Gulf of America” in the States.

We saw Elon Musk get awarded for his sycophancy with his Department of Regulatory Efficiency scheme. It didn’t cut costs, but at least it gave his unaccountable team of outsides a good chunk of sensitive information.

On the bright side, the breakup between Trump & Musk was legendary. 💅

Can we sod off with AI

It’s been a year of AI marketing hell. You can’t go a minute without some AI chatbot popup, marketing bollocks, or a memo asking you to use the latest AI helper your company has spent an eye-watering amount on. It’s frankly ridiculous.

The sheer continued hype by businesses over anything “AI”, despite dubious qualities, is insane.

For the record, this has been a year where “Microsoft is cautiously onboarding Grok 4 following Hitler concerns” was a headline. The words ‘hell future’ spring to mind.

Generative image & video models are able to create uncanny simulacrums. Whilst low effort AI slop drowned our parents’ Facebook feeds last year, now it’s moved on to provocative bollocks and fake animal videos that are becoming harder to discern from reality. Big platforms don’t care as long as it keeps user retention up.

It’s at the point where Instagram – the service dedicated to sharing photos – is swamped under generative AI fakery.

20 years ago it was a faff to upload images to the web, and there were fewer of them. As a result it was easy to tell what images were fake or not. In this hell world of constant easy content, it’s becoming harder under a deluge of generative AI.

Regardless of how much you keep your guard up, there’ll be something that tricks you, even for a moment. And being in a state of constant vigilance is making the web unfun.

Going into the new year, AI proliferation is bringing us hardware shortages and price hikes. AI companies are hoovering up so much hardware that we as consumers will be bearing the brunt of it.

The demand for NAND storage has sent the price of SSDs doubling. OpenAI have made deals to grant them 40% of the world’s DRAM output for the coming years, which has sent RAM prices skyrocketing. Samsung won’t even sell it to Samsung.

To put it into context: two years ago I spent £68 on the RAM in my computer, now that same RAM costs over £250. It’s madness.

It’s not just folks building their own PCs who’ll feel the sting, but whoever buys any device. Game consoles, phones, laptops, those weird smart fridges, you name it.

Web censorship ‘for the kids’

An unfortunate trend among the Western world has been the erosion of digital rights & privacy under the banner of protecting children.

The controversial Online Safety Act came into law over here, regardless of objections raised by tech experts, and it’s been a mess.

The terms for dealing with UK users are so long, draconian, and under the thread of fines that sites have opted to block UK users instead. This matters severely for smaller, niche hobby sites – not so much for the big companies who see fines as the cost of business.
Users are being asked to prove they’re an adult by sending pictures of their ID and having their face scanned by AI. Of course, these systems have faults and are easily bypassed

A lot of this sensitive data is being processed by overseas companies with lax security standards, and it’s only a matter of time before there’s a catastrophic data leak (earlier this year we saw Discord leak submitted IDs). And of course normalising scanning your ID has been a boon for internet scammers.

Is this really about protecting children from seeing “harmful content” online? Not really, the scope of what’s considered harmful is too large, and the risks of storing IDs is endangering everyone. But if you criticise it, you get told you’re on the side of Jimmy Saville.

Combine this with the Government’s plan for a mandatory Digital ID system, and it’s clear that it’s less about keeping the internet safe for kids, and more for keeping track of the content you see online.

Funnily just like everyone predicted a decade back, a simple VPN bypasses everything.

Of course we’re not the only place taking measures like this. Australia introduced measures to ban under-16s from Social Media, France and multiple US states now require photo ID for accessing 18+ sites – and of course, this can easily be expanded to include things like LGBT content.

Is the internet a safe place for kids? Not really, and it certainly feels less safer with the proliferation of online chat and the shift from the shared family computer to camera phones. But is this wave of legislation actually helping? I doubt it.

Silver linings

Okay, I don’t want to keep it all doom and gloom.

Meta finally admitted that their plans for a metaverse were a waste. $77 billion down the drain, and we won’t have to hear them market it ever again 🎉
Again, Skype is dead 🦀
As much as our parents are getting confused by AI slop, the sheer amount of it, as well as warnings from the media, are leading to more of them being cognisant about what might be AI or not
We’re seeing more core internet groups split off from parent companies and mergers to go independent:
- Giant Bomb, a major game reviewing site & streaming group broke free from Fandom
- Digital Foundry, a beloved games tech & hardware review team, left IGN a year after their Eurogamer buyout
- PC game storefront Good Old Games got re-acquired by its original co-founder, allowing it to strike free while CD Projekt Red can now focus solely on their RPGs

Life over here 🇬🇧

The UK’s certainly had better years. When the Labour party won last year’s general election, I was stoked; we finally kicked out the aimless sleazy Conservatives, the adults were finally in the room, and we could have meaningful change.

Unfortunately, the Labour they offered wasn’t the Labour we got.

You can’t undo 15 years of decline in a year, but Starmer has been particularly disappointing. Despite his majority he’s spent half the year u-turning on key policies, and using what little remaining capital on weird authoritarian measures (again, the Online Safety Act and pushing for Digital ID).

The general attitude over here is that we’re in a state of managed decline. Energy prices are still soaring, we’re not building enough houses, and it feels like radical change is impossible.

Not to say it’s all been terrible. The Renters’ Rights Bill seems promising, the Employment Rights Act is a step in the right direction, and subsidised buses means I’m not paying an arm and a leg to get anywhere. Can’t really fault that.

A key moment from this year was the Supreme Court’s ruling on the definition of a woman in the Equality Act in response to transgender women. It was ruled that it was written as to not include trans women, and despite the presiding judge commenting that it shouldn’t be seen as a triumph, the champagne spilt proved those words to be hollow.

What was supposed to clear up a point of confusion with the Equality Act has instead caused more confusion, invalidated gender recognition certificates, and has unfortunately fuelled the hostile attitude towards trans people in this country – to the point now where women are policed on facilities based solely on how they look.

I think it’s safe to say that things are still a mess.

Personal stuff

The stats

Blog posts: 8
6 books read
- Favourite: Enshittification
13 films watched
- Favourite: 28 Years Later
5 TV shows watched:
- Favourite: Pluribus
7 games played
- Favourite: Cave Story
Favourite song I listened to: Glad to Be Gay
Word of the year: Peccadillo

I mentioned last year that I could actually lose weight. Well towards the end of last year I went from 100kg to 90, and this year… Oh dear, I’ve been straddling that ever since!

Things wot I learnt

Neil Diamond sung about being Forever in Blue Jeans - not the Reverend Blue Jeans
- “I’d rather be Reverend Cool Jean’s babe” like this dude was so cool that would love be his wife?!
British watch company Sekonda got their start importing watches from the USSR
Robert Louis Stevenson wanted it to be pronounced Jee-kyll
Suicide Drones have are euphemistically named Loiter Munitions
Extraordinary Rendition is completely different to Extradition
WRT means with regards to

Blog posts wot didn’t make the cut

What I learnt rebuilding* 125 LEGO sets – I spent the first quarter of this year going through my childhood Lego bins in my spare time, trying to recover what sets I could.
- The Brick Separator is your friend
- Identify a set by a visually unique piece first
- Fight the temptation to build as you go along, collate the pieces first
- Know when to cut your losses. I only managed to complete 11 sets from loose parts.
On phones and handedness – I have weird hands, and with the size & weight of phones, it’s becoming increasingly impossible to use one with a single hand without causing considerate strain.
Brexit, 10-ish years on – A decade back we’d be in the midst of the whole referendum campaign, but how on Earth are you supposed to condense everything Brexit in a single blog post?

Highlights from around the web

AI: The New Aesthetics of Fascism – New Socialist
My 2 Year Journey to Solve the 30-Year Myth of Faceball 2000 – Stop Skeletons From Fighting
For-Profit (Creative) Software – EndVertex
Square Theory – Adam Aaronson
Why do AI company logos look like buttholes? – VelvetShark
The Timmy Trap – Scott Jenson
The BEST way to watch THE MATRIX… EVER! – Rocco Botte
What are you supposed to write about for an aortaversary? – Edward’s Blog
When Stick Figures Fought – Animation Obsessive
Disney’s living characters: A broken promise – Defunctland
Building the PERFECT Linux PC with Linus Torvalds – Linus Tech Tips

Conclusion

Eugh.

I don’t think much happened to me this year. I don’t want to be too negative, but circumstances have me stuck in a situation I’d rather not be, and right now depression is kicking my arse.

I don’t particularly have hope for the new year, but y’know, there’s a good chance it’ll be better. Last year I was hopeful, I was trying to be better, I didn’t want to give up on health, but… Eesh, trying to get help can be an uphill struggle over here.

A weird thing I tried doing this year was growing my hair out as a last hurrah. I didn’t really go ahead with it, looked too awkward. The longest it got was 1cm, which is fairly long for my tastes!

Also weird: this year my room didn’t get invaded by spiders or crane flies. Probably not a good sign in the long run.

Again, I think my friends have kept me sane throughout this year. That, and the regular forcing myself out the house to get a hot chocolate has helped.

Sorry to be a bit of a downer. Hopefully I read more books in the coming year. Cheers x

Olive

Gott Nytt År

Liza Shulyayeva — Wed, 31 Dec 2025 23:01:33 GMT

Happy New Year!

It’s been an interesting year. Mostly very happy, in some ways very sad - but then, aren’t most years like that for most people? Nothing can be all good all the time. There have been many highlights, and the ones I’m taking with me into 2026 are:

I canceled my book deal

Austin Z. Henley's Blog — Wed, 31 Dec 2025 22:00:01 GMT

https://austinhenley.com/blog/canceledbookdeal.html

January 2026

Gyanendra Mishra — Wed, 31 Dec 2025 20:30:00 GMT

.. I'm back - I’m back. It’s been over a year since I last wrote here—a brief California post in September 2024, and before that, July 2023. The writing muscle has atrophied. 2023 and early 2024 were active. Not consistent, but I was doing things. The running was there, I ran my first full...

The Golden Networking Hour

🦉 olshansky 🦁 — Wed, 31 Dec 2025 20:04:41 GMT

A simple rule of thumb for low-friction catch-up calls that don’t feel like meetings, and why Friday late afternoons are the sweet spot.

New Year's Resolutions 2026

Syd Norpol — Wed, 31 Dec 2025 20:00:25 GMT

Hello, hello.

I’m on line U8 rolling through the shallow tunnels towards Berlin Jannowitzbrücke. The guys next to me are unpacking their battery fireworks, asking me if I think that’s cool.

Recap #

I’ve been in three countries over the last month, or four (technically five) since September. I took three planes, took several Ubers, one sleeper train, one hotel, two hostel. Stayed at friends and friends of friends couches. I’ve stayed at three different apartments. I’ve rented two in parallel. Experienced two wonderful conferences. One I’ve just departed last night (39c3 💜)

Well, and during all of this I’ve also worked - fought my battles and I think it all worked out quite well.

Anyhow. As you might guess, a lot has happened and I’m greatful I could be an active part in that happening.

In hindsight, the year was wonderful - I’ve felt in average better than maybe even forever. There are still more good and wonderful changes ahead, but I would say I’m having a positive streak.

Well. Also, reviewing my past Resolutions I can comfortable say I’ve reached all of my high level goals and themes.

But what’s next?

Resolutions #

Well, I think part of what kept me going was hearing Lady Gaga saying:

You see? You can do anything, if you put your mind to it.

With that in mind!

enlighten others 🎤
explore new grounds 🪩
hold hands 💋
finish things 🚧🔨
breath well 🧘
focus on the aesthetics ✨💎

These are definitely in parts an experiment, yet they’re also what I could certainly vouch for myself.

Almost at Bellevue.
Bye and lots of love.

💜💜💜

Blender analog controller

ciesie.com — Wed, 31 Dec 2025 17:26:35 GMT

In the digital age you stumble on concepts analog in their nature. Modern graphics are created on a computer yet they originate in an analog process. You constantly change the brush size yet the computer allows you to do it in an increments. Do you actually care your color is R=53, G=123, B=200 in numerical values except when moving the data?

Concept of making an analog controller for art creation on the computer was always interesting for me. An exercise in this was this small controller built with Arduino. It’s just a 3 potentiometers dividing voltage. Arduino reads this voltage and sends the numeric values to Blender which can use them in various ways thanks to built-in Python environment. I used it to control color values.

Year in Review: 2025

Thought Eddies — Wed, 31 Dec 2025 17:00:12 GMT

Year in Review: 2025

Four Zero

Sunil Shenoy — Wed, 31 Dec 2025 14:12:35 GMT

Forty.

I used to rush to write this blog post every year, usually the day before my birthday on the 15th of December. But if this year had a theme, it was this: few things are rushed anymore. Things still get done. Just not in a hurry.

Less urgency. Less noise. More intention.

I turned 40 this year, and surprisingly, it doesn’t feel like a checkpoint. I remember turning 30 and spending a lot of time thinking about what I wanted to have achieved by that milestone. This year felt different. It felt more like setting the stage than checking boxes.

I was more intentional with my time this year and spent more of it creating space for what comes next.

A few years ago, I stopped setting strict yearly goals and started using themes instead. It’s given me direction without pressure, and it continues to work well for me.

Travel

I booked fewer trips for 2025 and a few tickets further out for 2026.

This year, I travelled to:

India
New Zealand
Poland

I moved between places at a slower pace than before and spent more time simply being where I was.

Most of this travel was about people. Catching up with friends, revisiting familiar places, and keeping things simple.

Fitness

Fitness stayed consistent, even when motivation didn’t.

There were good stretches and off weeks, but showing up regularly mattered more than doing things perfectly. Training gave structure to my days and helped keep everything else in balance.

Tech

This year reshaped how I think about building software.

I spent time learning to trust AI. Not as a shortcut, but as a collaborator. It changed how I approach problem-solving, debugging, and even thinking through ideas.

I also went deeper into Swift and SwiftUI, which stretched me in new ways. At the same time, I continued getting better at Ruby on Rails.

A lot of this learning came together while building cravingfor.app. It’s a product I’ve been steadily working on, refining, and living with day to day. This year was about getting it right. Shaping it patiently rather than rushing it out.

The app is close now, and it feels ready to be launched soon.

A Highlight

A few people asked what the highlight of the year was.

Swimming.

When I moved to Manly, the swim from Manly to Shelly felt like something I’d never be able to do. This year, I swam from Manly to Shelly and back a few times. Something that once felt out of reach slowly became normal.

Those swims weren’t about speed or distance. They were about getting in the water, trusting my body, and enjoying the movement.

Early mornings.
The ocean.
Steady breathing.

Love

This part of life stayed uncertain.

There were connections that didn’t last and lessons that took time to sink in. I handled things with more patience than before and felt less need to rush outcomes.

Projects and Space

This year, I stopped working on a lot of projects.

Some had been with me for a long time. Others just didn’t feel worth carrying forward anymore. Letting them go wasn’t easy, but it felt necessary.

The last few months, especially since August, were quiet. Sometimes boring. And instead of filling that boredom, I let it sit.

That space turned out to be useful. It helped clarify what mattered, what didn’t, and where my energy was better spent.

Overall

As I turn 40, I feel steady.

This year felt balanced. My health held up. Work felt intentional.

Here’s to 40.

Themes for 2026

More travel - Berlin, Norway, Barcelona, Lisbon, Qatar, and India
Apartment shift. Moving out of the apartment and finding a new apartment once I’m back
Spending more time building and growing cravingfor.app

No rush.
Just movement in the right direction.

Ending 2025!

Stories by Himanshu Singh on Medium — Wed, 31 Dec 2025 12:34:28 GMT

Hello there 👋
I’m Himanshu Singh — a software engineer working as a full-stack dev, leaning more toward client-side engineering.

Today is December 31, 2025, and I thought I’d write a quick blog post reflecting on my year.
2025 had a lot for me: I got laid off unexpectedly, spent months grinding, and eventually found my next role — and that’s just the headline.

Let’s begin.

🏁 Year Begins

The year started with me working with Stella (Previously Alpha Finance Lab) as a full-stack dev. I was working on a perpetual trading dApp, where I was pushing code in their Go back-end and Next.js front-end.

This was my first time working on the backend of a production app. Previously, for two years, I worked as a front-end engineer at my first employer, where I developed a crypto wallet extension.

The work was good. I was learning something new every day. During my tenure with Stella, I wrote a blog post whenever I did something new. All the AWS and backend blog posts I wrote here were part of my learning.

During the same time, we (as a family) did some real estate investments to build a financial cushion for us, as we had none. And, later, after closing that deal, we went for a family dinner out.

Everything was going ..

🏃🏻 Middle of the Year (Layoff, Job Hunt)

.. well.

I had also started posting my recordings on YouTube of my learnings. As it was my first time working with the Golang programming language, I was learning it on the side.

Then, on July 6, 2025, I received a message to speak on a call.

It never occurred to me that this was my last call.

In the call, I got to know that Binance had delisted the Alpha token that Stella had created, which had affected the project I was working on, and because of that, Stella had to terminate the project and let go of the team.

I didn’t know how to react, so I went silent.

The person told me he would share the doc for next steps with me, and I had a month on a termination period to find a job for me if I don’t want some gaps in my resume.

I didn’t know how to react that day. I was silent, and also didn’t touch my Mac after that call.

The good part was that they paid me for the notice period and gave me one month’s severance. And, since I didn’t have any EMI’s to pay, I was saved on that front.

And, the bad part of this was that it appeared that I was never part of the Stella team, as the folks I was working with never contacted me after that day.

Some context on the workstyle

I was working remotely with the Stella team from India. Most of the team is based out of Bangkok, Thailand, where Stella is based. We used to have sync-up calls once per week (first it was once a week, and then we started connecting three times a week). We used to discuss things on Telegram.

I was amazed that the team was not using Slack.

So, in the termination period, I began preparing for the interviews. I was applying for each job opening. I was sending cold emails to teams building in the web3 space, asking if they needed any new team members. But I was not getting any good response.

I was also sharing the complete journey on X (Twitter) and LinkedIn, as I believed that would help me get more eyes.

Some background on my first job

I graduated in 2022, and I have a Bachelor’s degree in Science honors in Computer Science, a three-year degree program in India. The degree is considered more on the theory side of Computer Science, less technical, which is why getting a good technical job after it is not very common. And because of it, at that time, I joined a bootcamp to get a job through it, as the bootcamp had a good network.

I gave my last semester exam on the 30th of May, and at the same time, in the camp, they started preparing for interviews. It went for a month, so around the second week of July, they started sending my profiles. But since I was expecting good pay, I didn’t get any calls from them. At that time, I had shared a post on Twitter (Back then. Now, X) and LinkedIn, that I was looking for a job, and got some good responses, which landed me my first job.

I had always believed in my knowledge, so I knew I would clear the interview.

And, my first job paid me well.

This time, the post on Socials was not helping.

And, as the termination period was about to end, I was panicked.

At that time, I started reaching out to other folks I had worked with. I reached out to a person whom I had worked with in Stella. He left the team after a few months of my joining. I asked if he could help me get interviews somewhere.

And he helped me schedule a call with my current employer. Then, I also heard back from the AltLayer team and got a call scheduled with them.

I gave interview rounds with both of them and submitted their take-home assignments. I was accepted into Skate but was rejected from AltLayer.

I asked the AltLayer team why they rejected my take-home assignment, and they sent me a reply with some comments.

Comments I got

- I was mixing the `viem` library and the `ethers.js` library. And, because it was not using hooks that `viem` supports. And, also for ERC20_ABI was using a JSON file instead of typed safe return from `viem`.
- And, at some places, the code could have been improved.

Later, I sent my response on why I was doing that, but as we know, they had made up their mind.

And then, I joined the Skate team on August 12, 2025. My termination period ended on August 8, 2025.

🎬 Year Ends (What I Learned, Gratitude)

And, since then, I have been with the Skate team, working on their AMM. Handling the frontend by myself, and pushing some PR in the backend here and there.

Through this experience, I learned that with experience, it becomes difficult to schedule an interview if you don’t know anyone, especially if your background is not very common, like a 4-year degree.

And I started making more genuine connections on my Socials. I am posting more recordings on YouTube. We are trying to increase our financial cushion.

That was my 2025 year

Not sure if anyone will read it, but if you are reading this line, then it means a lot to me, and let me know your thoughts or about your year in the comments.

If you want to check my recordings, please visit https://www.youtube.com/@hsnice16/videos

If you want to connect with me on X, please check https://x.com/hsnice16

I also maintain a personal log here https://personallogs.vercel.app

The reason I have used my employer’s name, instead of using aliases, is that my LinkedIn profile is public, so anyone can check the names

And, one more thing I forgot to mention, is that my first employer also approached me for a job.

I am grateful to all the folks who helped me throughout, all the folks who replied to the emails, supported my posts on Socials, and slipped in WhatsApp DM’s to share job openings with me.

And thankful to all my employers.

μCOM-87: The Strangest Architecture You've Never Worked With

ajxs.me — Wed, 31 Dec 2025 05:50:06 GMT

A short article about NEC's strange and mostly forgotten μCOM-87 processor architecture, as well as the Casio CZ-101 synthesiser that it powers.

2025 Year in Review

Love, Blood & Rhetoric — Wed, 31 Dec 2025 04:41:43 GMT

When I started this blog in 2018, my plan was to write a Year in Review post every December, hoping to document a trail of continued progress and success as a writer. And for a few years, I kinda did. [1] Then the pandemic hit, and everything went sideways. It took me a long, long […]

Sorting with Fibonacci Numbers and a Knuth Reward Check

orlp.net - Blog Archive — Wed, 31 Dec 2025 02:00:00 GMT

The following incredibly small sorting algorithm has an $O(n^{4/3})$ worst-case runtime:

def fibonacci_sort(v):
    a, b = 1, 1
    while a * b < len(v):
        a, b = b, a + b

    while a > 0:
        a, b = b - a, a
        g = a * b
        for i in range(g, len(v)):
            while i >= g and v[i - g] > v[i]:
                v[i], v[i - g] = v[i - g], v[i]
                i -= g

As the name implies, it uses the Fibonacci sequence ($1, 1, 2, 3, 5, \dots$) to sort the elements. In this article I will explain how it works, show an interesting divisibility property of the Fibonacci numbers and use that to prove its complexity. I will also explain how I ended up with one of Donald Knuth’s coveted reward checks.

Shellsort

The above sorting algorithm is an instance of the more generic Shellsort. Shellsort, named after Donald L. Shell, does not directly sort all the elements in one step. Rather, it first only sorts subsequences of the array in a process known as $k$-sorting.

$k$-sorting

When $k$-sorting an array you split the elements of the array up in groups, and sort those groups independently from each other. Each group is formed by taking every $k$th value ($k$ is also referred to as the gap), differing only by their starting point. For example, $3$-sorting an array with eight elements looks like this:

After this step we say the array is $k$-ordered. This means that for all $i$ we have ${A[i] \leq A[i + k]}$. Nothing is (directly) known about the relative order of elements which aren’t separated by a multiple of $k$. Since everything is a multiple of $1$, we see that $1$-ordered is just… sorted.

There is a fascinating property of $k$-sorting that is key to how Shellsort operates:

Theorem 1. If an array is $h$-ordered and then it is $k$-sorted, it remains $h$-ordered as well.

It is surprisingly tricky to prove this simple statement. A proof sketch paraphrased from a formal proof due to Knuth (TAOCP, Vol. 3, Chapter 5.2.1, Theorem K) goes as follows:

Lemma 1. If the last $r$ elements from array $Y$ are bigger or equal to respectively the first $r$ elements from array $X$, then this remains true after sorting both arrays.

Proof sketch. There are at least $r$ elements in $X$ which are smaller than or equal to elements in $Y$, thus the maximum element in $Y$ dominates at least $r$ elements, and thus the last element of $Y$ dominates the $r$th element of $X$ after sorting both. Apply a similar argument for $r - 1$ and the second largest element, etc.

A visual representation of this lemma really helps the understanding I believe:

Now we can use this lemma to prove our original theorem:

Proof sketch of Theorem 1. We have some array $A$ which is $h$-ordered, and thus we have $A[i] \leq A[i + h]$ for valid $i$. Then we $k$-sort it and now have $A[i] \leq A[i + k]$ instead. For any particular choice of $i$, define $X$ as $A[i + sk]$ for all valid integer $s$, and $Y$ as $A[i + tk + h]$ for all valid integer $t$. Then you can apply Lemma 1 to show that $A[i] \leq A[i + h]$ still remains true after $k$-sorting.

Once again I think a visual representation really helps here, especially to see the parallels with Lemma 1. Suppose we have a $3$-ordered array and then $5$-sort it. The proof sketch of Theorem 1 for $i = 2$ (and in fact for any $i \equiv 2 \pmod 5$) that we still have $A[i] \leq A[i + 3]$ can then be visualized as such:

I chose to only show a proof sketch rather than a full formal proof in this blog post, as I quote:

“This is much harder to write down than to understand.” — Donald Knuth

The result of this theorem is that as you apply more and more steps of $k$-sorting, all the work compounds into a larger overall ordering. Even with just two steps we can see very powerful results:

Lemma 2. If an array is both $h$-ordered and $k$-ordered where $k$ and $h$ are relatively prime (they don’t share any divisors other than 1), then two elements in the array which are at least $s \geq (h-1)(k-1)$ steps apart are in a correct relative order.

Proof. It is possible to write $s = \alpha h + \beta k$ with integer $\alpha, \beta \geq 0$ (for a proof of that see here). This means we can do $\alpha$ steps of $h$ (each time using $A[i] \leq A[i + h]$ since we’re $h$-ordered) and similarly $\beta$ steps of $k$ to see that $A[i] \leq A[i + \alpha h + \beta k] \leq A[i + s]$.

For example, here is a visualization of the relative order implied by the combination of $4$-ordering and $9$-ordering:

We see that indeed starting from offset $(4 - 1)(9 - 1) = 24$ each element is ordered relative to the element at 0.

More generally, we find that if we $k$-sort with some set $\{k_i, \dots, k_j\}$ and $\gcd(k_i, \dots, k_j) = 1$, then there exists some upper bound such that all numbers greater than it are representable as sums of non-negative multiples of $k_i, \dots, k_j$, meaning all elements beyond that point are ordered correctly relative to the starting point. Finding this upper bound is known as the Frobenius problem or coin problem, and it is a hard number theoretic problem. Some formulae like the above one for two coprime integers are known but the general problem for arbitrary sets of $k$ is NP-hard. It is this problem that forms the surprising link between Shellsort and number theory which will ultimately lead us towards the Fibonacci numbers.

Insertion sort

Shellsort uses insertion sort to $k$-sort the subsequences. This sort repeatedly swaps the last unsorted element with the element before it until it falls into place before continuing with the next unsorted element. This is generally speaking a rather inefficient algorithm for large arrays, as it has a worst-case of $O(n^2)$. However, this worst-case complexity can be refined. If each element is at most $m$ steps away from its final sorted position, insertion sort takes $O(nm)$ time.

And this is the key to Shellsort’s subquadratic worst-case complexity. You choose a clever gap sequence such that gaps start off very large leading to small subsequences and thus small $O(n^2)$ terms. Then, when Shellsort starts $k$-sorting with smaller gaps, you can use the fact that no element is very far from its final position to prove that it is still efficient. For example, based on our earlier observations, if the array is $4$-ordered and $9$-ordered and we do a $1$-sort (that is, a regular sort with no gaps) we know insertion sort can not run slower than $O(24n) = O(n)$ because each element is no further than $m = 24$ steps away from its final position.

Gap sequence

Choosing the gap sequence is thus key to Shellsort’s performance. The Wikipedia page lists many known gap sequences with different complexities. For example Hibbard’s 1963 sequence $k_i = 2^{i} - 1$ with $O(n^{3/2})$ complexity, or Pratt’s from 1971 which chooses all numbers of the form $2^p3^q$ for a complexity of $O(n\,(\log n)^2)$ (still the best known sequence to date, at least asymptotically).

However, all ‘new’ sequences listed after 1986 are empirically established, their complexities are unknown. They perform very well in practice, but they could possibly have much slower than expected performance for some inputs. A search on Google Scholar reveals no interesting new sequences either. With that in mind I’m happy to announce that Shellsort with the gap sequence

$$k_i = F_i \cdot F_{i+1} = (1, 2, 6, 15, 40, 104, 273, \dots)$$

where $F_n$ is the $n$th Fibonacci number has a worst-case runtime of $O(n^{4/3})$.

An interesting Fibonacci property

Before we can prove this worst-case runtime of gap sequence we’re going to need to take a look at the Fibonacci numbers in more detail:

$$F_0 = 0, \quad F_1 = 1, \quad F_n = F_{n-1} + F_{n-2}$$

This very well-known series of numbers $0, 1, 1, 2, 3, 5, 8, 13, \dots$ has all kind of interesting properties, but today we’ll need a very curious property where for $a, b > 0$, $$\gcd(F_a, F_b) = F_{\gcd(a, b)},$$ where $\gcd$ is the greatest common divisor function.

This property in plain words states that the greatest common divisor of the $a$th and $b$th Fibonacci number can be found by computing the greatest common divisor of $a$ and $b$, and looking up that index in the Fibonacci series.

Addition formula

To prove that we first need to prove the addition formula of the Fibonacci numbers, where $n, m > 0$, $$F_{n+m} = F_{n+1}F_m + F_nF_{m-1}.$$ A fairly simple way to do this is using the matrix exponential form of the Fibonacci sequence, $$\begin{pmatrix}F_{n+1}&F_n\\F_n&F_{n-1}\end{pmatrix} = {\begin{pmatrix}1&1\\1&0\end{pmatrix}}^n.$$

This form can be easily proven as correct using induction. With $n = 1$ you can directly see the equality holds, and to prove it holds for $n + 1$ assuming it holds for $n$ we have

\begin{align*} {\begin{pmatrix}1&1\\1&0\end{pmatrix}}^{n + 1} &= {\begin{pmatrix}1&1\\1&0\end{pmatrix}}{\begin{pmatrix}1&1\\1&0\end{pmatrix}}^n = {\begin{pmatrix}1&1\\1&0\end{pmatrix}}\begin{pmatrix}F_{n+1}&F_n\\F_n&F_{n-1}\end{pmatrix}\\ &= \begin{pmatrix}F_{n+1}+F_{n}&F_n+F_{n-1}\\F_{n+1}&F_{n}\end{pmatrix} = \begin{pmatrix}F_{n+2}&F_{n+1}\\F_{n+1}&F_{n}\end{pmatrix}. \end{align*}

Then, using the fact that in matrix exponentiation $A^{n+m} = A^n \times A^m$ we find:

\begin{align*} \begin{pmatrix}F_{n+m+1}&F_{n+m}\\F_{n+m}&F_{n+m-1}\end{pmatrix} &= \begin{pmatrix}F_{n+1}&F_n\\F_n&F_{n-1}\end{pmatrix} \times \begin{pmatrix}F_{m+1}&F_m\\F_m&F_{m-1}\end{pmatrix}\\ &= \begin{pmatrix}F_{n+1}F_{m+1}+F_nF_m&F_{n+1}F_m+F_nF_{m-1}\\F_nF_{m+1}+F_{n-1}F_m&F_nF_m + F_{n-1}F_{m-1}\end{pmatrix}. \end{align*}

Our desired addition formula can then be read from the top right element of both sides of the matrix equation.

If we generalize the Fibonacci formula a bit to allow negative indices we find that $F_{-1} = 1$ (which is the only choice preserving $F_{n} = F_{n-1} + F_{n-2}$), and that the above addition formula also holds for $n > 0, m = 0$ which we’ll need in a bit.

Divisibility and coprimality

We also need to prove that $F_{kn} \equiv 0 \bmod F_{n}$ for all $k, n > 0$. If we do induction on $k$ it obviously holds true for $k = 1$, and we see that if it holds for $k$ we have \begin{align*} F_{(k + 1)n} \equiv F_{kn + n} &\equiv F_{kn+1}F_{n} + F_{kn}F_{n - 1}\\ &\equiv F_{kn+1} \cdot 0 + 0 \cdot F_{n - 1} \equiv 0 &&\mod F_{n}. \end{align*} In other words, $F_n$ divides $F_{kn}$, also written $F_{n} \mathrel{|} F_{kn}$.

Finally we need to prove that $\gcd(F_n, F_{n+1}) = 1$, meaning consecutive Fibonacci numbers don’t share any prime factors (they are coprime). This is once again proven through induction, the property holds for $n = 1$ and since $\gcd(a, b) = \gcd(a, a + b)$, we have $$\gcd(F_n, F_{n+1}) = \gcd(F_n + F_{n+1} , F_{n+1}) = \gcd(F_{n+1}, F_{n+2}).$$

Euclidean algorithm

The Euclidean algorithm is an algorithm to compute the greatest common divisor based on the identity $$\gcd(a, b) = \gcd(a, b - a),$$ where $1 < a < b$. By repeatedly applying this identity (swapping $a, b$ when needed to keep $a < b$) until $a = 1$ you’ll find the greatest common divisor. You can speed up the algorithm by replacing the repeated subtraction with the modulo operator: $$\gcd(a, b) = \gcd(a, b \bmod a).$$

Now, suppose we are computing $\gcd(F_a, F_b)$ with $0 < a < b$. We can write $b = qa + r$ with $q \geq 1$ and $0 \leq r < a$, this is just splitting up $b$ into the quotient $q$ and remainder $r$ when dividing by $a$. Then, using the addition formula we find

$$\gcd(F_a, F_b) = \gcd(F_a, F_{qa + r}) = \gcd(F_a, F_{qa + 1}F_r + F_{qa}F_{r-1})$$

We proved earlier that $F_{qa} \equiv 0 \mod F_a$, so applying the above modular identity we can eliminate the $F_{qa}F_{r-1}$ term, $$\gcd(F_a, F_b) = \gcd(F_a, F_{qa + 1}F_r).$$ We also know that $F_{qa+1}$ and $F_{qa}$ are coprime. Since all factors of $F_a$ are factors of $F_{qa}$ we can conclude that $F_a$ and $F_{qa+1}$ share no (prime) factors either. This property lets us eliminate that factor from the greatest common divisor calculation entirely: $$\gcd(F_a, F_b) = \gcd(F_a, F_r).$$

Since $r = b \bmod a$ we note the following symmetry when $1 < a < b$:

$$\gcd(a, b) = \gcd(a, b \bmod a),$$ $$\gcd(F_a, F_b) = \gcd(F_a, F_{b \bmod a}).$$

In other words, by repeatedly applying the above identity we can perform the Euclidean algorithm on the indices of the Fibonacci numbers, giving $$\gcd(F_a, F_b) = F_{\gcd(a, b)}.$$

Fibonacci sort’s complexity

Now, for the actual proof I have to stand on top of the shoulders of giants. Recall that our gap sequence was as follows:

$$k_i = F_{i} \cdot F_{i + 1}.$$

In the 1986 paper A New Upper Bound for Shellsort by Robert Sedgewick, a formula due to Johnson is shown (Theorem 4) which lets us bound the Frobenius term $g(a, b, c)$ for three numbers $a, b, c$, assuming that they are independent. The Frobenius term $g(a, b, c)$ is what we discussed earlier in our analysis of Shellsort. It means that for all $n \geq g(a, b, c)$ there exist some combination of non-negative integers $\alpha, \beta, \gamma$ such that $$\alpha a + \beta b + \gamma c = n.$$

Conversely, independence means none of the numbers can be written as a linear combination of the others with non-negative integer coefficients. Assuming $i \geq 2$, for $\{k_i, k_{i+1}, k_{i+2}\}$ it is easy to prove the independence using our earlier GCD formula. From this we establish that $$\gcd(F_{i}, F_{i+1}) = F_{\gcd(i, i+1)} = F_{1} = 1,$$ $$\gcd(F_{i}, F_{i+2}) = F_{\gcd(i, i+2)} = F_{2} = 1,$$ and thus $$\gcd(k_{i}, k_{i+1}) = \gcd(F_{i}\cdot F_{i+1}, F_{i+1}\cdot F_{i+2}) = F_{i+1}\cdot \gcd(F_{i}, F_{i+2}) = F_{i+1}.$$ This directly proves that $k_{i+1}$ is not a multiple of $k_{i}$. This leaves one other possibility, that $k_{i+2}$ is dependent on $\{k_i, k_{i+1}\}$: $$\alpha k_{i} + \beta k_{i+1} = k_{i+2}$$ $$\alpha F_i F_{i+1} + \beta F_{i+1} F_{i+2} = F_{i+2}F_{i+3}$$ $$F_{i+1}(\alpha F_i + \beta F_{i+2}) = F_{i+2}F_{i+3}$$ This can only be true if $F_{i+2}F_{i+3}$ is a multiple of $F_{i+1}$, but $F_{i+1}$ is coprime with both $F_{i+2}$ and $F_{i+3}$ as we saw earlier, and thus this rules out any dependence.

Frobenius bound

Since we have proven independence we can use Johnson’s formula from the above paper. It states that $$g(a, b, c) = d \cdot g\left(\frac{a}{d}, \frac{b}{d}, c\right) + (d-1)c$$ where $d = \gcd(a, b)$. This lets us use the formula for coprime $a, b$ we saw in Lemma 2, because when $a, b < c$ and $a, b$ are coprime we have $$g(a, b, c) \leq g(a, b) = (a - 1)(b - 1) \leq ab.$$ In our case this means that $$g(k_{i+1}, k_{i+2}, k_{i+3}) \leq F_{i+2} \cdot g(F_{i+1}, F_{i+3}) + F_{i+2}F_{i+3}F_{i+4},$$ $$g(k_{i+1}, k_{i+2}, k_{i+3}) \leq F_{i+1}F_{i+2}F_{i+3} + F_{i+2}F_{i+3}F_{i+4}.$$ If we now use the asymptotic approximation $F_n = \Theta(\phi^n)$ where ${\phi = (\sqrt{5} + 1)/2}$ we have

$$k_i = \Theta(\phi^{2n}), \quad g(k_{i+1}, k_{i+2}, k_{i+3}) \leq \Theta(\phi^{3n}).$$

In other words, $g(k_{i+1}, k_{i+2}, k_{i+3}) = O(k_i^{3/2})$.

Back to Shellsort

We proved just above that after having processed gaps $k_{i+3}, k_{i+2}, k_{i+1}$ the maximum distance for an element from its true location is no more than $O(k_i^{3/2})$. Then if we perform a $k_i$-sort next, we have $k_i$ subsequences of length $n / k_i$ in which the maximum distance of an element from its sorted location within that subsequence is no more than $O(k_i^{3/2} / k_i) = O(k_i^{1/2})$.

Recall from earlier that insertion sort on a subsequence of length $n$ where each element is at most $m$ places from its sorted location has complexity $O(nm)$. This means the $k_i$-sort step for all subsequences combined takes at most $O(k_i \cdot (n / k_i) \cdot k_i^{1/2}) = O(n \cdot k_i^{1/2})$ time. This bound is good when $k_i$ is small, but we also have a different upper bound which is good when $k_i$ is big, using the fact that insertion sort takes at most $O(n^2)$ time. This gives us the bound $O(k_i \cdot (n / k_i)^2) = O(n^2 / k_i)$ as well.

We note that both bounds are equal when $k_i = \Theta(n^{2/3})$, giving us $O(n^{4/3})$ overall by consistently choosing the smaller of the two bounds. To make this a bit more formal, let $t$ be the maximum index such that $k_t \leq n$, and let $s$ represent the index on which we switch our bound. Then we have $$cT \leq \sum_{i=1}^{s - 1} \left(n \cdot k_i^{1/2}\right) + \sum_{i=s}^t \left(n^2 / k_i\right),$$ where $T$ is our total runtime and $c > 0$ is some ‘constant’ irrelevant for the asymptotic analysis (varying from equation to equation). Then, substituting the asymptotic approximation for $k_i \approx \phi^{2i}$ we get $$cT \leq n \sum_{i=1}^{s - 1} \phi^{i} + n^2\sum_{i=s}^t \phi^{-2i},$$ $$cT \leq n \cdot \frac{\phi^s - \phi}{\phi - 1} + n^2 \cdot \frac{\phi^{2 - 2s} - \phi^{-2t}}{\phi^2 - 1}.$$ Removing constant factors from terms and substituting $s = 2t/3$ gives us $$cT \leq n \cdot (\phi^{2t/3} - 1) + n^2 \cdot (\phi^{- 4t/3} - \phi^{-2t}).$$ Finally we note that within a constant factor $\phi^{2t} \approx k_t \approx n$ to simplify to $$cT \leq n \cdot (n^{1/3} - 1) + n^2 \cdot (n^{- 2/3} - 1/n),$$ $$cT \leq n^{4/3} + n^{4/3} - 2n,$$ giving our overall bound of $O(n^{4/3})$.

Generalizing

The above proof is analogous to the one found in A New Upper Bound for Shellsort by Sedgewick, I don’t claim credit for it. Ultimately there is nothing fundamental about the choice of the Fibonacci numbers here, any sequence which starts with $1$ and:

grows like $\Theta(b^{2n})$ for some base $b$,
has a greatest common divisor on the order of $\Theta(b^n)$ for consecutive terms, and
where any three consecutive terms are independent,

should have a $O(n^{4/3})$ runtime when used as a gap sequence in Shellsort. For example, Sedgewick himself used (among others) the sequence $$k_1 = 1, \quad k_i = (2^i - 3)(2^{i+1} - 3),$$ but it is pretty neat that the product of consecutive Fibonacci numbers can be used here as well.

In fact, we can generalize our Fibonacci sequence to a simple way of constructing sequences that match the above set of criteria. Simply start with a sequence $A_n$ where any three consecutive elements of $A$ are pairwise coprime and grow like $\Theta(b^n)$, then define the gap sequence as $$k_i = A_i \cdot A_{i+1}.$$

Real-world performance

So… is Fibonacci sort any good in practice? As far as shellsorts go, it is middle-of-the-pack. I also found a similarly structured sequence (with a similar $O(n^{4/3})$ proof) which performs quite a bit better:

$$A_1 = 1, \quad A_2 = 1, \quad A_3 = 2,\quad A_n = 2A_{n-2} + 1$$ $$k_i = A_i \cdot A_{i+1} = (1, 2, 6, 15, 35, 77, 165, \dots)$$

The advantage of this gap sequence, like the Fibonacci one, is that it is a simple reversible recurrent formula meaning the implementation does not need a lookup table, and can compute the gaps on-the-fly. This is useful, because in my opinion Shellsort only truly has one niche where it shines: tiny code size. I think it’s a solid choice for places where every byte of code matters, while still giving a decent algorithm.

I ran a simple benchmark for the number of comparisons performed by the following gap sequences:

Algorithm	Formula	Complexity
`hibbard63`	$k_i = 2^{i} - 1$	$O(n^{3/2})$
`pratt71`	$k = \{2^p3^q\mid p, q \in \mathbb{N}_0\}$	$O(n\,(\log n)^2)$
`sedge86a`	$k_1 = 1, k_i = 4^{i} + 3\cdot 2^{i-1}+ 1$	$O(n^{4/3})$
`sedge86b`	$k_1 = 1, k_i = (2^i - 3)(2^{i+1} - 3)$	$O(n^{4/3})$
`sedge86i`	$k = \{4^j - 3\cdot 2^j + 1\} \cup {\{9\cdot 4^j - 9\cdot 2^j + 1\}}$	Unknown
`lee21`	$k_i = \lceil\frac{\gamma^i - 1}{\gamma - 1}\rceil, \gamma = 2.243609061420001\dots$	Unknown
`fib25`	$k_i = F_i \cdot F_{i+1}$	$O(n^{4/3})$
`orlp25`	$k_i = A_i \cdot A_{i+1}$	$O(n^{4/3})$

I also added heapsort as a $O(n \log n)$ comparison datapoint as it too is a small in-place unstable sort. The results are as follows, with a log scale for size $n$ on the X-axis and the number of comparisons divided by $n \log_2 n$ on the Y-axis:

As you can see fib25 doesn’t perform great nor terrible. My other sequence orlp25 performs almost as good as the best experimentally derived sequences, but still provides a worst-case guarantee.

Knuth Reward Check

The astute observer may have seen sedge86i marked as having an unknown complexity in bold. However, the Wikipedia page for Shellsort at the time of writing lists it as $O(n^{4/3})$. While writing this article I did quite some reading of Sedgewick’s 1986 paper A New Upper Bound for Shellsort, in fact I originally found the paper through a reference on the Wikipedia page for that sequence.

While reading the paper I noticed that there are two theorems he proves both of which lead to $O(n^{4/3})$ behavior, Theorem 5 and Theorem 6. Theorem 5 requires as a key property that $k_i, k_{i+1}$, and $k_{i+2}$ are pairwise coprime for all $i$. Theorem 6 requires as a key property that the greatest common divisor of consecutive terms $k_i, k_{i+1}$ always is on the order of $\sqrt{k_i}$ (that’s the theorem I used above).

But sedge86i which consists of the merger of two sequences satisfies neither property, nor do the individual sequences before merging!

\begin{align*} \{4^j - 3\cdot 2^j + 1\} &= 5, 41, 209, 929, 3905, 16001, 64769, 260609, \dots\\ \{9\cdot 4^j - 9\cdot 2^j + 1\} &= 1, 19, 109, 505, 2161, 8929, 36289, 146305, 587521, \dots \end{align*}

As counterexamples in the pre-merged sequences we find $\gcd(209, 3905) = \gcd(36289, 587521) = 11$, and $\gcd(16764929, 37730305) = 29$ in the merged sequence. In fact, if you read the paper, Sedgewick only describes the merged sequence in his conclusion section, as such:

The particular sequence used here is a merge of the sequences […]. These occasionally have triples that are not relatively prime, but the combination does better on random inputs than the sequence of Theorem 5 because it has more smaller increments.

Sedgewick never claims this particular merged sequence leads to a worst-case of $O(n^{4/3})$. So why is it listed as such on the Wikipedia page? After more digging I realized that the sequence is also found in Knuth’s TAOCP, in Volume 3, Sorting and Searching, Chapter 5.2.1. At the time Knuth wrote:

The final examples in Table 6 come from another sequence devised by Sedgewick, based on slightly different heuristics. When these increments $(h_0, h_1, h_2, \dots) = 1, 5, 19, 41, 109, 209, \dots$ are used, Sedgewick proved that the worst-case running time is $O(N^{4/3})$.

Except Sedgewick did no such thing (nor did he claim to). I guess whoever edited the Wikipedia article read Knuth’s book and assumed that statement was correct.

Contacting Knuth

I emailed Knuth with my findings, and a good few months later I received a physical letter containing:

my email printed out with a few pencil scribbles,
a reward check for finding an error.

The errata for Volume 3 now read (emphasis mine):

These increments […] combine two sequences that resemble increments for which Sedgewick proved the worst-case time bound $O(N^{4/3})$.

Swimming review: 2025

Jamie’s blog — Wed, 31 Dec 2025 02:00:00 GMT

This post probably is not for you. It’s the indulgent reflections of a middling mid-life swimmer who really needs to remember to be proud of himself and, if he doesn’t write all this down, he’s likely to forget he did any of it.

Highlights

First swim races/events in 10 years
- Gaelforce Trilogy (3.5km, 3.9km, 3.9km)
- Garnish Island (5km)
Personal bests set this year:
- 800m
- 1000m
- 1500m
- Longest open water swim (5.6km)
- Longest swim (8km)
- Highest annual total (316,517m)
Shoulder injury: recovered
Left ankle: recovered
Right ankle: new injury!

Preamble

The start of my 2025 swimming really started in late-2024 and with an unlikely joint.

I’d been having ankle problems for about 18 months and working with a physio and rehab exercises in the gym to fix it. I finally got a specialist consultant appointment, and another MRI, and was diagosed with osteoarthritis in the ankle joint. That wasn’t a surprise since it has two screws in it from a car accident. Before Christmas I had an injection of hyaluronic acid into the ankle so I had to rest for a week, and only light swimming.

But none of that mattered because I’d also buggered up my right shoulder.

I started 2025 sitting on the couch, unable to swim, and figuring out how best to protect my ankle. Logically, I thought, this was the best time to sign up for The Gaelforce Trilogy—three swims in river, lake, and sea between May and September. The only swim events I’ve ever done were 10 years ago and that was a 1km “paddle in the park” and the 2km Lee river swim. With a few clicks I’d just entered a 3.4km, 3.9km, and 3.9km race and I wasn’t sure if or when I’d be able to swim again.

January: Meh

It was a miserable month with almost no swimming. In it’s place was lots of physio on the shoulder, particularly dry-needling on the infraspinatus and lats. Infraspinatus is a nasty muscle to have dry-needled as the pain radiates over the shoulder and down the arm. Did not enjoy.

I started doing some cardio sessions on the bike at the gym just to replace the swimming and keep me active. Also meh.

February: Slightly-less-but-still Meh

I got back to some light swimming, mostly drills like sculling and fists to build up the rotator cuff without tightening everything up again. Still doing lots of rehab work in the gym and at home.

The number of exercise bands in the house multiplied.

March: I’m (slowly) back

I was finally back swimming around 2-2.5km sessions, without pushing it, and continuing all the physio and rehab work in the gym.

I did a CSS test to determine my threshold pace which came out as 1:42/100m

April: Training hard

Things are starting to get serious with The Great River Swim only 6 weeks away. I needed to get out of the pool and into the open water but, even with some unseasonably warm weather, the sea was still freezing cold. I got in two short (<1km) swims during the month and that’s about 8 weeks earlier than I’d ever been in the sea. Having the race was a huge factor forcing me into the water much earlier, and much less comfortable, than ever before.

I was swimming between 3-4 times per week, 2 sessions in the gym, and rehab exercises each day it felt like I was seriously training for the first time in my life. There was rarely an “off” day. Apparently, and this still sounds ridiculous in my head, I need to think of myself as an “athlete” and prioritise fueling, training, and recovery accordingly.

Got some new pool goggles: Arena Cobra Ultra Swipe. They really live up to their marketing hype of being anti-fog, which is a first for any goggle I’ve owned. Just wet the googles, swipe the inside with a finger, and hey-presto: no fog. That said, I tended to favour the Magic5 goggles for most swims as they are, by far, the most comfortable pairs I own.

May: The Great River Swim

The unseasonably warm weather had continued and we were treated to the best of Irish weather: blue skies, sunshine, and not too warm. We took the shuttle bus up to the starting point and the guy next to me asked how long I thought it would take me. I thought about 1:10 depending on the current. He replied, “oh, wow. You should have been in Wave 1 with the elite swimmers”. Um… what?

The river was lower than usual and as we entered the water I looked around and started to wonder if maybe I was going to be faster than most of the wave. I moved up towards the front of the pack at the start line but there was still a fair number of people in front of me when the race started. I started swimming, filled with nervous adrenaline, but unfortunately some of the people in front of me hesitated or were waiting for more space. I kinda swam over one person and my elbow hit some part of another. Sorry. That was my first experience of the chaos of a swim start.

I’d not swam in a river in a long time and I’d forgotten how easy it is: the current suited my long smooth stroke, the water was calm, and there was basically no navigation required. It was like swimming on rails, just following the meandering river from one corner to the next surrounded by reeds on either side.

After a few minutes I’d cleared most of the other swimmers but there was maybe 3 ahead of me. One by one I started passing them out. And then I started passing out people from Wave 1 which had started 10 minutes before us. And some swimmers from, I think, the 12km event that had started hours earlier—they were looking pretty exhausted by that point.

After maybe 1km, I noticed someone drafting on my feet but they weren’t touching my toes so, whatever, enjoy the free ride! Coming up to the bridge, which was the only real navigation required, I spotted the family on the bridge and gave them a quick wave then put my head down and lost the person on my toes. I managed a bit of a sprint for the finish and then struggled to actually get out!

The random song for the day, by virtue of having these few lines stuck in my head for the entire swim:

Gotta give a little something
Gotta take a little pain
Gotta dig a little deeper
We gotta keep the faith
Hell or high water
We didn’t come to lose
—Eclipse, We didn’t come to lose

I finished the 3.5km course in 0:58:43: first in Wave 2, 10th place overall, and 2nd in my age group. A very good result for my first race! Though, upon reflection, most of the better swimmers were probably doing the 5.8km or 12km races. Something for next year, maybe.

I was tired afterwards and my lats were pretty sore but otherwise I felt really good about it. There was a nice little festival atmosphere at the end and I enjoyed sitting on the grass afterwards having a picnic of Coke and fizzy jellies with the family. My daughter repeatedly told me how proud she was of me so that was good.

After the swim I flew out for the company retreat in the US… and came back sick. Again. 😖

June: Mallorca

June kicked off with the SwimSmooth course in Mallorca. There’s really nothing more I need to add to my blog post about the experience in 2024. It was a different group of people but the experience was just a good, the 50m pool at the BEST Centre was as glorious as ever, the hotel was nicer, and the coaching just as valuable.

I set a new CSS of 1:35/100m showing that the training I’d done for the river swim had paid off, but I then spent the week trying—and failing—to live up to it! 🥵

I think I was still recovering from being sick but I completely died during one memorable pool session. I’d never experienced anything like that before: I was at the end of the pool, holding on, and I knew someone was talking to me but I couldn’t actually hear them or process the words. I ended that session early but it lives on in the SwimSmooth Guru app as “Jamie’s Downfall”. I also remember leaving everything in the pool after some sprints and being destroyed afterwards. My shoulder injury also flaired up on another session but was mostly ok for the rest of the week.

I left inspired after a conversation with Paul and I entered the only 5km swim left in the Irish 2025 swim calendar: Garnish Island. It was a swim I’d wanted to do for a while but it sells out quickly and I’d never had the confidence to enter the 5km distance. I had until mid-August to prepare.

At the end of June I was back in Brighton for the Brighton Ruby conference and, of course, took advantage of the wonderful 50m Sea Lanes pool on the beachfront. I was a bit apprehensive about the Garnish Island swim so I decided to prove to myself that I could swim 5km by doing 10x 500m. Then I did it again the next day to prove to myself that I could do it when I was fatigued.

July: The Great Lake Swim

It was one of the hottest days of the year at Lough Derg for the Great Lake Swim, with the air temp around 30°C and the water 22°C.

I swam the 3.9km distance in 1:06:46, placing 14th overall and 7th in my age group. I was pretty happy with that as it was at the faster end of my prediction. I also swam non-stop and, again, enjoyed passing lots of Wave 1 swimmers. After the first few hundred meters, I told myself that I wasn’t going to let anyone pass me—and I didn’t.

I’m not really competitive but I do enjoy setting challenges for myself even if that means using other people to do it. Another mental game I played was thinking of passing other swimmers as “taking caps” (though, of course, I’m not actually assaulting them). Anything to pass the time and make it interesting.

There isn’t much room in my brain for thinking during a race. I’m just constantly iterating between sighting for the next buoy, looking out for other swimmers/kayakers etc, enjoying the view of the weeds and fish, repeat a line from a song, counting my strokes (for no reason), reminding myself to stay calm, to relax, and to keep my form.

After around 2km my thumbs and index, middle, and ring fingers felt like they were wrapped in elastoplast: they felt big, slight pins & needles, and I couldn’t feel them well (but could still move them). They weren’t white. I could keep swimming but I had less feel for the water. It went away after a few minutes on shore. The same thing had started creeping in during the river swim and the 5km in the pool but it was more obvious now.

I felt a bit flat afterwards. I didn’t have the high of the first swim and I didn’t have anything to really compare myself to. Was this a good time? I didn’t really have any external reference for was “good” looked like.

August: Garnish Island

August was about preparing for the Garnish Island swim and I kicked off my birthday with my longest open water swim: 5,600m around Myrtleville. I rarely plan things out and I never tell anyone what I’m attempting but I thought a really good long swim in the sea what give me some more confidence going into the Garnish Island swim.

The birthday swim was also an opportunity to try something I’d never done before: feeding. Packed into a new donut tow float I had a Rice Krispy Square, Precision Fuel energy gels, and some ‘Zero’ electrolytes. I made a point of stopping after the second and third laps to feed even if I felt like I didn’t need it.

My birthday also brought a new watch as a present! Hilary bought me a Garmin Forerunner 570 to replace my beloved-but-aging Garmin Swim 2. I was apprehensive because of the “Forerunner” name but all the same swim functions were there and the buttons did the same thing so my muscle memory still worked. I also got lots more data like HRV, training readiness, training effect, better sleep data, ability to track strength workouts, water temperature, recovery time… and a lot more I don’t pay attention to. I highly recommend this watch for swimmers.

And, most interestingly, I was finally able to install the SwimSmooth app on the watch to analyse my stroke. Sure enough, my top priority is to fix my straight-arm pull, particularly with the right arm.

Glengarriff was packed on the day of the Garnish Island swim, as it is most weekends during the summer but now there were a few hundred swimmers & spectators there too. I left the family in town to get food and I took the shuttle bus to the starting point on my own. That felt kinda weird as they’d always been there to see me off in the previous races.

The song on today’s mental jukebox in a 10 sec loop was Halestorm’s Everest:

It’s the shame, it’s the pain, something I can’t explain
It’s a noise, it’s a voice, and it screams in my brain
It’s a curse, and it hurts, but I just keep going

It’s a fairly simple course: out from the slip to the island, two counter-clockwise loops, and a straight swim back. I stuck to my plan of executing one lap of the island (~2.5km) and then stopping for a feed. I think I only stopped for about a minute and just had a quick drink but it was a revelation! Feeding (or, as I told the kayaker, my picnic) made me feel like I could swim… forever?! It was also a fun and varied swim: calm heading out, then a bit of chop, then we were practically surfing with the waves behind us, and finally back to a serene bit of water.

My goggles started fogging up after about 100m so I had to flip onto my back, take them off, spit into them, rinse them, and pop them back on.

Garnish was an event (not a race) so there was no official timings or positions but my watch timed it at 1:30.31 for the 5km. For what it’s worth, Strava had me at 4th for those that recorded it, and 7th best time for that route. I don’t put a lot of stock in that but I felt really good.

The 2km Myrtleville Swim, postponed from June, was cancelled again. I reckon the stars will never align for me to complete that one.

September: The Great Fjord Swim

After Garnish Island I stopped really worrying about the Killary Fjord swim. I’d just swum 5km and I’d done 3.9km back in July so this should be a walk in the park. Right?

My preparation wasn’t great with a few weeks of low mood, low energy, and conference travel getting in the way of some long training swims. Mostly I managed 3km sessions.

A week out from the swim, the weather forecast looked pretty wet & windy. With a westerly windy, it would mean the wind coming from behind us on the first leg, and into our faces on the return journey.

My plan was just to start reasonably close to the front of the wave, use the first kilometre to get settled, then nice calm swimming with long strokes into the turn. Then I knew we’d be into the wind and the chop, and it would be a higher tempo fight on the way home.

The forecast materialised as predicted with 25kph winds, gusting 45kph, funnelling straight down the fjord but, apart from a rain shower as we walked down to the start line, it stayed dry for the swim. We even got a lovely rainbow and some blinding sunshine on the swim out. Thankfully the organisers had changed the route from a looping rectangular course to a straight out-and-back, sticking close to the shore where it wasn’t quite as lumpy.

Today’s song was The Pretty Reckless’ For I am Death:

For I am death and I can feel
I got my hands upon the wheel
I am not lost
For I have found the only one
Who put me down
For I am death and I won’t break
I got a life
I’ve got to take
When will it end, this sufferin’ of late?
It was nice to know you

You might have wondered what thoughts go through a swimmer’s head as it’s being pounded by waves for an hour and a half, but you probably didn’t expect this man in his 40’s, wrapped in neoprene, to be saying “for I am death… for I am death… for I am death” on repeat.

Things mostly went as I thought they would: I started well and got ahead of the pack. When my goggles started leaking after about 100m, I rolled onto my back to fix them and there was a few people ahead and no one on my feet. Yes, the same thing that happened in Garnish Island. I think I need a better system of getting the goggles race-ready.

I continued for what felt like foreverrrrrr. The only notable events on the outbound leg was nearly missing a buoy because it was positioned closer to shore and I was sighting on the next one, and my tow float being constantly blown forward and banging into my elbows. The wind might have been with us but it was a pretty frustrating experience because on every single recovery the tow float would be blown into my arm.

I decided that I’d take a quick break at the second turning buoy. My fingers were already numb and I knew it was going to be a slog on the way home. I took 40secs to have a pee (don’t judge!) and stretch out the arms then I headed into it.

“It” was choppy waves that constantly slammed into my head, dug into my arm, or left me catching thin air. I channelled all the videos of Darragh swimming around Ireland or Ross battling through immense storms around Iceland. Conditions weren’t that bad, it wasn’t as far, and I wasn’t that good, but the visualisation helped a lot.

I staggered out, leaning on a volunteer for support after 1:29:18; 31st overall and 9th in my age group. My watch measured the course at 4.5km though and this seemed to be corroborated by a few others. The time and placings might not look as god but I think it was the most competitive race I’d done and the conditions were easily the worst I’d swam through.

October-December

Bleugh. I wasn’t feeling in love with swimming for October and November and, even though I was on sabbatical for a month, I swam less than usual.

Then I hurt my achilles. My other ankle. I started this year with a busted left ankle and finished it with a busted right ankle. Thank god I’m a swimmer and not a runner.

I started the SwimSmooth 10 week CSS challenge for something to do. My CSS test came out a little slower (1:36/100m) than in Mallorca and I didn’t decrease the CSS pace each week as I was supposed to.

I really enjoyed one of the sessions each week which had 800m of drills, 400m of 50m fast/slow/tempos, 8x100m at CSS pace, then some variation of 1000m at CSS (400/300/200/100, or 2x 500m etc). I became a lot more comfortable swimming at my threshold pace and by Christmas I was struggling to swim slow enough! Instead of 1:35/100 I’d be hitting 1:30, 1:32, 1:32, 1:32 (no, I was really trying to go slow on that one), 1:32 (wtf!), 1:34… though I still struggled with the pace on longer intervals and I definitely still struggled with the rest times.

With the short fast/slows in that set, I started wondering how hard a 1:00/100m sprint is. It’s fucking hard and I’m waaaaaaayyyyy off (about 1:20). Still, it’s kind of an interesting medium-term goal. A 20m pool isn’t ideal because you hardly get going before you’re turning again, and I don’t usually tumble turn (I can—I just don’t like it and I’m not fast at it). Oh, and I can’t dive in this pool. Anyway, I played around with sprinting a bit for fun and managed to hit a 1:00 pace for a single length (12 secs for the 20m) and 1:07 for two. It’s a milestone. Maybe I’ll do something with it next year.

The pool was closing early on the 23rd December and I got it into my head to attempt a long swim which might help me decide on some goals for next year. Like, a really long swim. I chose 8km as a potentially achievable distance though it would be my longest swim ever. 2x 400m, 12x 600m, and 2h40m later I got it done. Interestingly, I swam it at an average 1:42/100m pace which was the threshold pace I started off with in March and I’d have struggled to maintain for much more than 1000m back then. I spent the rest of the day on the couch!

Whilst writing this I also discovered that I was just 2km shy of my highest annual total so, yeah, you bet I got in the pool and claimed that PB too.

Inspiring swims of the year

Instagram is my drug of choice for swim content and there was a ton of inspiring swims to enjoy this year.

It was incredible to watch Darragh Morgan’s swim around Ireland and Ross Edgley’s swim around Iceland. Absolutely insane overall distances, insane daily distances, insane sea conditions. Insane. Loved them.

Brian Foster did a triple Fastnet Swim, breaking the record for the one-way swim, and then breaking the record for the two-way swim, and being the first to complete the triple. Also insane.

We also had the Olympics! Watching Ireland’s Daniel Wiffen win the 800m was a source of national pride. Bobby Finke’s amazing 1500m final was stunning from the start. “Can he hold on? Can he? He fucking can!”—I loved it even as he was beating Wiffen. And then there’s Katie Ledecky: I can’t get enough of watching her dominate the 1500m.

I saw Catherine Breed’s Faralon Islands swim, Sarah Thomas just repping out daily 10km swims for practice, Hector Pardoe swimming the three longest lakes in the UK in under 24hrs, and Amy’s double Windamere.

David from the SwimSmooth Mallorca camp did a double crossing of Lake Geneva. Paul was an inspiration again, winning the Oceanman 10km in Dubai and showing what your 40’s can look like.

Next?

I think before I got into the water in Lanesborough I realised I might have under-estimated myself; by the time I got out I knew I had. I was a bit apprehensive about the 5km swim in Garnish but I quickly proved to myself I could do it. And the 3.9km swim at Killary proved I swim in tough conditions—though it was a real slog.

As soon as the Gaelforce Trilogy was over, I started looking ahead to swims I could complete in 2026. I’m inspired by these massive swims I see other people doing but I’m also resolutely uninterested in cold water—I just don’t enjoy it or find it rewarding, or invigorating, or feel the need to prove myself according to “channel rules”. I have no intention of swimming the English Channel.

I’d like to do a 10km swim (a marathon distance for the runners still reading this indulgant rubbish). Or, more precisely, I think I’m capable of swimming 10km and I’d like to have done it. The actual doing of it isn’t likely to be pleasant.

As of New Year’s Eve, I’m thinking of redo-ing the Gaelforce Trilogy but this time as 12km for the river swim, 3.9km for the lake (still the longest at that event), and the new 8km distance for the fjord. I think the river is doable though remembering the look of those 12km swimmers I passed adds a bit of reality to my optimism. The fjord makes me nervous if only because it’s 8km, straight West into the prevailing wind, which might be howling like this year.

I’m not sure I want to travel for swim races. The UK is convenient, and has a lot of events, but the water conditions aren’t good and there’s a lot more expense and logistics. I’d also like to do an Ultraswim (33.3km over 4 days) but not sure I make the dates work or convince myself I have the endurance for it. Very tempting though.

Random Reflections

Wave 2 is quite nice. I enjoyed the less aggressive start line energy, relished the game of catching Wave 1 swimmers, and it was definitely easier having a constant stream of swimmers with their colourful tow floats to guide the way. That said, if I do it again next year I should be starting in Wave 1.

Advice to paddlers: don’t bother talking to a swimmer when they are swimming. We can’t hear a thing with the sound of the water and some people need to use ear plugs. Pointing your arm or paddle in the direction is far more effective. You’re really more like a sheepdog that uses it’s body, not its bark, to control the sheep. Ideally position yourself to the left or right of the swim route and use your presence to shepherd swimmers in the right direction—we’ll try to steer away from you and the closer you get, the more urgently we’ll move. Mostly.

I’ve taught myself to celebrate like an Olympian. It’s all too easy for me to complete a tough set, maybe set a new PB, and get out of the pool, sit in the sauna, get changed, leave, and mention it to no one. Instead, I’ve started celebrating like I’ve just won the Olympics: shouting “YES!!”, “Fuck, yeah”, punching the water etc. The pool isn’t usually busy so I’m not disrupting any one though I probably appear like a lunatic. I don’t care. No one else knows what I’m doing, no one else cares or understands what I might have achieved, but my body does and it deserves to physically celebrate that achievement. It deserves more than just a mental nod of approval and slinking off home.

Songs for swims. A single line of lyrics on repeat can get me through a swim so I have a curated playlist now.

Feeding is great. I need to do this more and it really opens up longer swims. There’s also a mindset change about not worrying about distance so much and thinking more about continuing for a certain duration.

Numb fingers thing is annoying. I think it could be Thorasic Outlet Syndrome (nerve restriction around the collarbone) and I’m going to investigate more in the new year to see if there are exercises I can do to reduce it.

Coaching and strength training. I’ve been swimming ~3 times a week for about 12 years but in-person coaching and strength training in the past 2 years has brought my swimming to a completely new level. Don’t sleep on it (I wish I didn’t).

Comparison is the thief of joy. I’m not as good as many other swimmers and there’s plenty of opportunities to remind myself of that. On the other hand, I’m practically elite compared to the general population and I’m much much better than past-Jamie.

Jam Dojo

june.kim — Wed, 31 Dec 2025 02:00:00 GMT

25 Questions to ask yourself every year

Gourav Goyal — Wed, 31 Dec 2025 02:00:00 GMT

25 questions to ask yourself every year

🎄 Advent of EIP Day 8: Building a Production Webhook Delivery Platform

James Carr — Wed, 31 Dec 2025 02:00:00 GMT

Happy New Years for my APAC friends! In my previous post we traced the evolution from synchronous request-reply to enterprise event delivery platforms. We built recipient lists, webhook registrations, and bundled integrations. But we glossed over a critical question: what happens when delivery fails? In production, failure isn’t exceptional. It’s constant. Endpoints go down. Networks partition. Rate limits trigger. Servers restart. A webhook platform that doesn’t handle failure gracefully isn’t a platform at all.

Favorite books of 2025

Nithin Bekal — Wed, 31 Dec 2025 02:00:00 GMT

35 books, 17,000 pages. That fell short of the 50 books target I set for myself, but there were quite a few great books in there. Most of my “reading” this year was through audiobooks, so I ended up listening to 240 hours (that’s 10 whole days!) worth of books.

2025 Year in Review

Ben Overmyer's Site — Wed, 31 Dec 2025 02:00:00 GMT

Well then. 2025 did not go as originally planned. Not even close.

A year of challenges

We attempted to foster a puppy in January. She was a cute little rescue pit mix named Clover. Unfortunately, I discovered that I'm allergic to dogs. I don't know if this is new or if it's just something I never noticed before. While it seems to be a relatively mild allergy, combined with other factors, it meant we had to stop fostering. Luckily, there was another foster family able to take Clover right away.

The next event of consequence was Trump taking office. We knew it was going to be bad, but even my worst fears paled compared to what he did. In response, we decided I would attempt a different route to immigration. I started applying to as many universities in Canada and Estonia as I could.

In March, one of them accepted my application: Memorial University of Newfoundland. So, we immediately began the planning process to move to Newfoundland. In April, we flew up to St. John's to explore the area and see if we could find a rental that would accept cats. We were shocked to discover that rentals mostly disallow pets, with no possibility of pet rent or anything like that. However, we got lucky, and found a three-bedroom house whose landlord loves cats. So, we signed the lease and started paying for two places at once. While it meant the new house would stand empty for several months before we could move in, we guaranteed that we'd have a place.

It was around this time that I completed the most complex painting I've ever done. It was a painting of my sister's eleven cats, and originally meant as a Christmas gift. Still, a nice achievement, and she ended up loving it.

The painting of Tasha's cats

For the next few months, we watched as Trump ran roughshod over all the rules and rights that normally guide the government and began systematically destroying the United States. Then it came time to give notice at our jobs and prepare for the two-week drive it would take to get to our new home in St. John's, Newfoundland.

The trek northward

That drive took us to some amazing places with great views. Under other circumstances, it would have been a wonderful experience. However, I had our two cats and a ton of possessions crammed into my Kia Seltos, and the cats hated that drive. I will never put them through that again.

Mojave and Kalahari a few days before we took the trip

Still, we got to our destination safely, with everyone and everything intact. We moved into our new place in mid August. The UHaul U-Box arrived more or less on time, and we got everything that we'd brought with us sorted out. The majority of our stuff is still back in Wilmington, North Carolina, though, in a big storage unit. We can't bring all that up until we get permanent resident status. That won't happen until after I've graduated and we've both spent a year living and working here.

In order to retain access to our US bank accounts and a few other services, we have to retain our US phone numbers. We're using US Mobile for that purpose; it's about $15 USD per month for the two lines on the lowest service level. We have new Canadian numbers at the same time. Surprisingly, it was easy to get Canadian bank accounts and credit cards. Sarah was able to get a remote job to pay the bills, and for the first semester of university, I even got an internship that paid a reasonable amount of money.

Starting grad school

My first semester was stressful. I had to reacclimate to the university life, and between three classes, an entrepreneurship program, and my internship, I was extremely busy. One of my classes, Applied Algorithms, was really difficult for me. After a ton of studying, consulting my dad, and working with ChatGPT (and, later, Gemini) to understand the concepts, I managed to finish the class with a B, but it was a struggle. If you get less than a B in a class at the graduate level, you fail the class and have to retake it. If you fail two classes (or the same class twice) this way, then you're kicked out of the program. If you're an international student, that immediately invalidates your study permit, and you are required to leave the country. So, you can understand why I was stressed.

In the end, though, it worked out. I got As or Bs in all of my classes, and passed the entrepreneurship program. I finished my internship successfully, with an invitation to come back if I ever want to.

So, about those planned new habits

With regards to the new habits I originally intended to set this year, the events of 2025 completely derailed everything. I couldn't bring my guitar with me, so the guitar habit died around about May. I was improving quickly, though, and apparently I can borrow a guitar from the local library here in St. John's, so maybe I'll pick that back up now.

The painting habit never took, though I have painted more this year than any other year since art school. I'm improving at that, too, and I now have a basic painting setup in the new place. There's promise here for 2026.

Alcohol... well, quitting alcohol didn't happen. While I didn't drink as much this year as previous years, I still drank way more than I planned to. This will be another thing I address in 2026.

The daily walking habit never formed. However, I did start walking more in St. John's compared to Wilmington, since there are a number of amazing trails here that are really close to our house. It should be easy to establish a walking habit going forward. I can even walk to campus in about an hour and fifteen minutes, which is ambitious but doable.

One of the trails near our house

Books read

My boss Dwayne at Apiture introduced me to the novel series Dungeon Crawler Carl early in the year, and I adored it. I read everything that was available, and for Christmas I got the latest book in the series, so I intend to start on that early next year.

I also got into the Dune novels after playing the survival MMO Dune: Awakening, and read up to Chapterhouse: Dune, which is the last Dune novel written by Frank Herbert. They were a strange and unusual series of novels. I have no idea how they could make a third Dune movie in the current series without touching on some very weird concepts from the books.

Total books read this year: 20

Music discovered

A little over a month ago, I started a new habit of discovering and buying a brand new album every Friday. I wanted to expand the collection of music that I actually own, as opposed to just streaming everything. My record player is still in storage in North Carolina along with all of my records, so I'm just buying digital albums. Still, it's led me to discover some fascinating new music that I otherwise would never have heard.

I've discovered that I enjoy thrash metal and black metal. One unusual standout was Bloodywood, a nu metal band from New Delhi with Hindu and English lyrics. They even did a collaboration with Babymetal, a unique Japanese metal group that I used to follow years ago.

Hmm. Maybe I should start an "albums discovered" page in the same vein as my "books read" page.

Yoga progress

Another unexpected development this year is that I started getting into yoga. I start most mornings now with a basic routine that takes about 5 minutes. My skill level is still "absolute beginner," though. There are classes here in St. John's, but I don't have a lot of spare money for such things. I enjoy the practice, and use yoga workouts on Apple Fitness+ to learn new asanas.

I am interested in the other aspects of yoga, too, and not just the stretching. The world view is worth exploring.

In closing

That's some of our adventures from 2025. I skipped mentioning a few things, but this post is already quite long enough. 2025 was a year of big changes. One thing is certain: no one will ever say 2025 was boring.

Previous Years

2025 Superlatives

cjlm.ca — Wed, 31 Dec 2025 02:00:00 GMT

In lieu of a more thoughtful end of year review, here’s a smattering of extremes from my 2025.

Best song of 2025

Mary by Black Country, New Road

Perfect harmonies. Evocative Stuart Murdoch-esque lyrics. I love the loop-de-loop phrasings and emotional climax on “powers”. Total ear-worm.

Best bouncy guilty pleasure songs I listened to the most in 2025

Tied: Side Eye by Matt Embree and Can We Talk About Isaac by Rachel Chinouriri

Best show of a Victoria, BC artist that I saw while visiting Hamilton, ON (or: starkest ratio of effort level from the band to number of audience members)

Frog Eyes

The song my car played the most this year as it’s the first song, alphabetically on my phone

…A Few Final Bars by Bill Evans Trio

Best photo I took in 2025

Best thing that someone shouted at me when when I was panting and sweating cycling up a hill

“Well done for riding a REAL bike”

Best job I quit in 2025

I loved working for CI for 9 years but it was time to move on.

Entrepreneurial blog post that I’ve thought about most this year

You can have two Big Things, but not three by Jason Cohen

Best song lyric from the new Mountain Goats album that would be the title of my personal essay about John Darnielle if that was something that hadn’t been done to death by now

Is this not what you wanted from the sea?

Most boringest reason not to run a half marathon that I registered for in 2024

We booked a trip away.

Best reason not to run a (different!!) half marathon that I registered for in 2024

I broke my little toe stubbing it against a bookcase carrying my child across the room.

Best app

Albums - a Apple Music client that focuses on albums and shuffles your library to surface new, old and interesting releases.

Best book I read in 2025 (fiction)

I Who Have Never Known Men by Jacqueline Harpman

Best book I read in 2025 (non-fiction)

A Prehistory of the Cloud by Tung-Hui Hu

Runner up: Language Machines by Leif Weatherby

Best book about Eels that I read in 2025

The Book of Eels by Patrik Svensson

Earliest graphic novel ever written (?!) that’s also really good (that I read this year)

Gentleman Jim by Raymond Briggs

Best breakfast sandwich I ate in 2025

Adriana’s BACON EGGER (BACON, EGGS, ARUGULA & LEMON PESTO) in Tofino

The book I think about the most that I read in 2025

The Expectation Effect by David Robson

I read this after listening to McKinley Valentine raving about it on a podcast. As a pop-science, “this will possibly change your life” sort of book, I didn’t expect to finish it but it was worth the read. In short, it’s about the strange effect the expectation of something can change your experience of it. When you tell yourself that you only have enough energy to do a certain amount of stuff, is that really the case or are you just telling yourself that?

Lowest number of books read in a year since I started tracking books I’ve read on my website

26 in 2025.

Best domain I’ve purchased this year

https://practicegui.de

Lost in the Glitch shutdown and originally built by thricedotted. I wanted to give this fantastic little site a new home.

It’s a nice reminder to stay grounded when working on something creative.

I couldn’t help but add one (1) new feature: the ability to prepopulate it with URL parameters.

Best movie that I haven’t seen yet and have somehow avoided spoilers but I know will be amazing

Nirvanna the Band the Show the Movie

Best movie I saw in the cinema in 2025

One Battle After Another

Best score from a movie I saw in the cinema

One Battle After Another – such a fantastic, nervy backbone for this movie.

Best score from a movie I haven’t seen yet

Smashing Machine by Nala Sinephro

The latest, best Destroyer song released in 2025

Hydroplaning off the Edge of the World

Best radio station

CFUV, local campus radio from University of Victoria

Best tracks discovered due to listening to CFUV

Curtis Mayfield - We’re a Winner (Live)
It’s Getting So (That a Man Can’t Go into Town Just to Have Him a Drink) - Colter Wall
You’re Between Me - Pure Prairie League
Drizzly - Dun-Dun Band
The Road to Trantor - Carl Schultz
O My Heart Is Full - Luka Kuplowsky
Water No Get Enemy - Red Hot Org

Best website I built in 2025

Turns out CFUV doesn’t keep a record or broadcast metadata so, inspired by Now Playing for BBC Radio 6 I built a little app that Shazam’s the radio stream every 30 seconds to try and log what’s playing. It’s surprisingly effective!

https://nowplaying.cjlm.ca

Runner up: my new venture: https://ammil.industries. More to come here in 2026.

Best Raffi song

To Everyone in All the World - legit beautiful song, looks like it’s a Pete Seeger song.

I think the reason Raffi reigns supreme as the best of the best children’s music is that he never condescends. So earnest and authentic.

Best Instagram Reel I found in 2025

I’m not on Instagram but checked in on the profile of one of my favourite comedians (after his appearance on a hilarious episode of The Town Show) – Mark Little.

Pinned (for good reason) is this beaut.

Best sort-of-mantra I cobbled together that actually helped me more than I expected this year

What do you want people to associate you as? The sort of person who would eat a whole cake or go for a run. To be on their phone or reading a book?

Best show I went to in a bid to go to more live shows despite not finding anyone who wanted to go to the shows with me

Dead Bob @ Encore

(Honourable mention to band “Mean Bikini” for their progressive hardcore skate punk supporting set)

Runner up: Wine Lips @ Lucky Bar

The Port I Couldn’t Ship

Honourable mention: Does Smitten Kitchen have a Chocolate Zucchini Bread Recipe?

Second honourable mention: it feels like gambling

Best thing Claude “said” to me

Are we actually working on something here, or are you just fucking around now?

Best articles I read in n+1

Best fiction I read in n+1 in 2024 that I still think about

Arnie Robles Jr. by Paul Soto

Most entertaining email received

My friend Andrew T’s latest music mix

These teeth are of the universe, and I feel clearly that I should be sharing them with the dentistry school for the good of human society. My only regret is that I didn’t do this sooner (because of complacency).

Best album title from 2025

Getting Killed by Geese

Runner up: Cuntry by Cleo Reed

Best song from the 2025 album, Getting Killed by Geese

100 Horses. First heard this on the radio driving around in a rental car in the North of England. The combo of the laconic, out of time vocals with that impossibly funky second guitar line made me feel like I was in space.

Weirdest PR for an album that threatened to sap all the fun out of a really good release

Even Cillian Murphy’s son is listening to it – an email I got from MerchNow referring to Getting Killed by Geese.

Best song to listen to in the car (if you’re my child)

Lollipop by the Chordettes

Weirdest lyrics for a 1950s song

Lollipop by the Chordettes

The day the font on my website becomes the widest it has been all year

Today. Let me explain. Inspired by Dave Rupert, back in May I added some code to my personal site https://cjlm.ca that made the header wider each day. The font itself, in case you were wondering, is Fit by the wonderful David Jonathan Ross – a font that just begs to be as wide as physically possible.

The page title became a strange marker of the passage of time this year, it will feel weird to see it snap back to tiny at the stroke of midnight.

I'm sick and tired of AI coders

ブラック — Wed, 31 Dec 2025 02:00:00 GMT

This has been a weird year for me, with the biggest thing being that I suddenly found myself without a job. This was a bit of a new experience for me, since I hadn’t been unemployed ever since I graduated. Had to fill all kinds of government paperwork about it. Not exactly the happiest of circumstances to find yourself in, but I came into it from a much better starting position than many of my fellow layabouts, so I’ll refrain from crying about it too much.

Now I’m back in the workforce again, still making computers do things for us. Those things are just a bit different, and I’m doing them in a different environment, but I didn’t suddenly become a bricklayer or anything. I’m still even a remote employee, so I didn’t even have to go into the office like many of my peers did. The biggest difference though? I am now in a company where my coworkers, or at least the most vocal of them, have taken the AI pill – hard. And I really don’t care for it.

I’m a proponent of the idea that you get better at things by doing them. That’s why I have a goal of playing my guitar for at least 15 minutes every day, no matter what. I’m currently ~1700 days into this experiment, so that should have given me 425+ hours to improve my playing. According to Malcolm Gladwell, that’s over 4% of mastery. It’s also part of why I started a blog, since even if nobody were to read anything that I wrote here, I’d at least give myself a chance to improve my writing. Not that I write here that often, but I feel like it has still helped.

This is one of the reasons why I’m skeptical of "agentic coding": I don’t think I will become a better developer by letting an AI model write code for me. And I’m almost certain that I won’t become a better developer by doing it like some of my coworkers are doing it. Some of them do not seem to do any kind of validation on the code beyond the fact that the unit tests (which the AI wrote) pass, the integration tests (which the AI wrote) work, and that the documentation (which the AI wrote) is accurate (as evaluated by the AI).

Supposedly the easiest way of catching students using AI to cheat on their homework is simply by asking them questions about their work. The chances are that they will not be able to actually tell you what is inside whatever it is that they’ve just turned in. I can’t vouch for the veracity of this method, but I have noticed that the people who are using agents to code don’t really seem to know what’s inside the commits they’re shipping out. Presumably there are teams where AI is used in a responsible manner and people make sure to understand what they are shipping, but at least where I work, velocity seems to come before reason or understanding.

I’ve seen the LinkedIn post of the tech executive praising their AI-native chief vibist, who is pushing out 250,000+ lines of code every month. That comes out to around 12,000 lines of code generated each working day. Obviously I can’t write 12,000 lines of code in a single day, but I don’t think I can review 12,000 lines of code in a day either. Is the price of our glorious AI-generated future that we just don’t look at the code that we ship?

It really boggles my mind how some people can put so much trust in these language models. I don’t even trust my own code this much; I always go through my own code again before I submit it to be reviewed by another person. Either I’m the odd one here for double-checking my work, or LLMs have blinded developers into thinking they’re near-infallible 10x coders and reviewing their changes serves only to unnecessarily slow down your business. But from my experience working with a codebase that has a significant amount of AI-generated code in it, I think mistrust is the right call.

The general quality of our AI-generated code is quite poor. Claude does very little in terms of adhering to DRY, it’s writing CRUD tests against completely barren databases, and if a test doesn’t pass, it might solve the issue not by changing the core business logic, but rather by changing the test until it passes. And I can't even really get into the truly important specifics, like for example what Claude is doing with access control. We probably wouldn't pass a security audit even if the audit was done by Claude itself.

It feels like every day I discover a new problem that can be described as "developer prompted the ticket, didn’t check it, didn’t run it". There’s only so much code that I’ve had time to look at, or run, so I don’t even know how far the rot has spread. Most of these are in a greenfield project that has yet to land on the monitors of end-users, so the customer experience thankfully hasn’t been impacted. And most importantly, I have never had to interact with a customer, so even if they were interacting with all of that vibe, they couldn’t associate my face with it. If I had to meet with the clients, I'd prefer to hide my face with a paper bag or something.

Unfortunately these terrors are often committed by the same AI evangelists that are always telling us to "not trust the AI blindly" in our many agentic coding meetings, with Claude's --dangerously-skip-permissions always enabled. Why have I even had to attend multiple of these meetings anyway? Surely vibe coding hasn’t changed that much in a month that I needed a refresher course.

The non-coding parts are also not that great in my opinion. We’re churning out so much AI-generated documentation that there’s zero chance that anyone with a beating heart will ever read them. Probably why the text reads like it’s written for other robots. I think the only place where most of the text is written by humans at this point is Slack, and it also has a bunch of AI transcriptions too.

Jira tickets are also hallucinated by LLMs. You know what’s a right laugh? Getting assigned a third-party integration ticket where all of the details on the external service have been made up by a GPU. Someone just had an AI fill out a whole document out of a single-line "Allow fetching data from [CRM service]". The only usable part was the name of the service. None of the use cases or API endpoints existed. It's fairy dust; it doesn't exist, it's not fucking real.

I'm not even that opposed to maintaining documentation, but I did try to use Claude to update the CHANGELOG.md file on my behalf. Unfortunately it managed to generate excruciatingly detailed technical descriptions of all of the changes, so I just deleted all of it, and rewrote it by hand. Hopefully this way the next developer can actually read through the changelog and not ask their AI agent to summarise the changes for them.

I’ve also noticed that trying to ask Claude about our codebases is also not that great. While debugging a problem that Claude had sidestepped by rigging the tests, I asked Claude to identify if we were validating the data we’re entering into our database. Claude then told me that we don’t have database constraints to validate anything, but we’re checking them in the code before it hits the database. I then looked and there was a function to validate the data, but absolutely nothing called it. And when I unrigged the tests, broken and unvalidated data was entered into the database. Shocking. Thankfully I had already determined the root cause before asking Claude, so I wasn’t led astray and only wasted some time looking up that unused code.

The single best use case for Claude that I've seen so far is code reviews. Before, I'd first review my changes myself, then I'd push it to remote and ask someone else to review it for me. Now I can first review it myself, then ask Claude what it thinks of my changes, and only then waste another human's time on it. The reason why I like it is that it has good upsides and minor downsides; if it notices something important, great, I can change it, and if it gets an absolutely abhorrent idea for a change, I can just ignore it.

And since LLMs can understand natural language and code, I can ask one to check if my documentation is technically accurate, which I can then fix myself. As much as I'm shitting on AI, I do actually find this useful. Although not useful enough that I'd actually pay Anthropic for a subscription, and I presume the current prices are heavily subsidized.

As far as the coding tasks that I entrust Claude, I'm currently keeping it for advanced copy-paste tasks only. By this, I mean that I might write five unit tests for a single model by hand, and then ask it to write tests for another model based on those previous handwritten tests. The way I'd have normally gone about it would've been to copy-paste the original tests anyway, so Claude can do it a bit smarter. Unfortunately, even when I've given it an explicit template for what it needs to write, it still has managed to conjure other test cases from outside my specific example, so even this use case is far from perfect.

I think code reviews also become quite interesting in terms of development team dynamics. I’ve seen pull requests co-authored by Claude with thousands upon thousands of lines of changes, and I don’t know if I can bring myself to review them. How much of my day am I going to devote to reviewing this change? And will I end up spending more time looking at this code than the guy who supposedly co-authored it with Claude?

I mean, I’ve definitely had to submit large changesets for review too, but at least I was not asking other people to work harder on reviewing the code than I worked writing it, since those large pull requests took real effort. And I definitely couldn’t open several of them per week.

So far I’ve been flying under the radar, trying to only snipe the smaller code reviews, and leaving the ones with tens of thousands of lines to other developers. I did start reading one larger change too, but someone approved it before I could really get going. Judging by how fast my coworkers get them approved, I can only assume that they’re checking the changes as rigorously as they are checking ~~their own~~ Claude’s work.

Unfortunately, I think AI has come to stay when it comes to software development. No idea what kind of a place the industry has for me in the future. The Internet keeps telling me that I am one of the ones who will be replaced. But I just can't imagine getting up in the morning and have the motivation to just prompt a model all day long. Personally, I’ll try to keep writing code by hand as long as I can, just like I write documentation and blog posts by hand, and enjoy the process and struggle.

I imagine my time at my current place of work is going to be relatively short. My tenure is measured in months, and I'm already pretty sick and tired of the culture. My feelings towards work are so bad that I'd probably sleep better if my employment was terminated tomorrow. Presumably for shipping code too slowly or something, although I don't think anyone has really made a note of how organic my code still is. The only thing that keeps me going is receiving a steady salary, and I've still considered just outright quitting before finding my next job.

The lesson learned from the current job? Figure out how any prospective employer is using AI before continuing, as nobody brought it up before my hiring, and I only discovered having joined a slophouse when I was already in it, and got told that I am expected to code using AI. Probably would've been better for both parties if they'd just told me ahead of time.

Setting up WireGuard on Synology DSM 7 using Docker and Gluetun

Nelson Figueroa — Wed, 31 Dec 2025 02:00:00 GMT

A guide to connect a Synology NAS to a WireGuard VPN server, with qBittorrent as an example.

An Utterly Incomplete Look at Research from 1925

Brett Mullins — Wed, 31 Dec 2025 02:00:00 GMT

Seven years removed from the armistice, 1925 finds the Western intellectual world grappling with reconstruction, not merely of borders and economies but of the conceptual foundations underlying science and the social order. The selections below reflect this theme of rebuilding. Economists theorize about institutional frameworks and the distinction between productive investment and mere speculation. Philosophers return to perennial questions about universals and common sense with renewed rigor. Statisticians formalize the inferential machinery that would come to dominate empirical research.

The First Day of the Rest of My Life

The David Brownman Blog — Wed, 31 Dec 2025 02:00:00 GMT

Some personal news that changes everything, forever (for the better).

Read the whole thing.

The year of the artificial intern

Monroe Clinton — Wed, 31 Dec 2025 02:00:00 GMT

This year I went from having not a single subscription to paying for ChatGPT, Gemini, Cursor, and Grok. My usage of these tools makes it well worth it, according to “Your Year with ChatGPT” I’m in the top 1% of users for the number of ChatGPT messages sent for 2025. I’ve been looking for a replacement to Google search for years, and I’ve finally found it. The LLM tools are just as inaccurate as what you’d find on a typical Google search result page, but they are much more convenient.

Year in community

Notes on software development — Wed, 31 Dec 2025 02:00:00 GMT

This year I ran three book club readings over email with 1,230 unique attendees. I ran 12 coffee club meetups in midtown Manhattan with 170 unique attendees. Angelo and I ran 6 NYC Systems meetups with 12 different speakers and 281 unique attendees. I took 3 visiting PhD students out for Banh Mi.

I raised $6,915 for educational non-profits, offering chats in return. I got coffee, lunch, or took 30 minute calls with 55 people I'd never spoken to before in person or on video. (Most, but not all, were in return for fundraising receipts.) This list included women and men based in the USA, Germany, Canada, Nigeria, Nepal, India, the United Kingdom, Brazil, New Zealand, Israel, and Australia. (I think I'm forgetting one or two.)

Thank you to every person who has been a part of these efforts, making them so special and so valuable. See you in the new year!

Year in community pic.twitter.com/n7jrmsZiKN
— Phil Eaton (@eatonphil) December 31, 2025

2025

La Vita è Bear — Wed, 31 Dec 2025 02:00:00 GMT

旅行

2025 flight map

今年继续超越去年成为我有史以来飞得最多的一年。主要来自于去英国看了三次球：上半年去温布利看我队几十年来第一冠，然后下半年买了个欧冠四场主场套票（还剩一场一月去看）。

然后今年飞了 Alaska Milkrun，算是划去了 bucket list 里面的一项。然后今年去日本的时候去了以前没去过的九州岛，感觉福冈这个地方在日本有点类似国内的成都：有大城市的便利，但是人们又活得非常安逸没多卷，吃得也好/有特色，难怪现在在日本也算热门搬入城市。

影视

今年看了六十几部电影，跟去年一样因为长途飞得多有挺大比例是在飞机上看的。印象比较深的几部是：

然后今年因为飞机坐得实在太多最后没片可看了就看了些曾大热但之前一直拖着没看的电影，像是卧虎藏龙, Crazy Rich Asians, Anora 之类的。

电视剧方面，热点和 Common Side Effects 都相当不错。

娱乐

今年大热的 Expedition 33 和 Silksong 都相当不错。另外我玩了 Citizen Sleeper 1 和 2，这个系列算是一种低配版 Disco Elysium 代餐，但是在代餐里面算是文本相当不错的。

然后今年玩了很多重制的老游戏，像是时隔多年终于又能在掌机上玩 Patapon 1+2, 和逆转裁判 456 加上逆转检事合集。年底又刚开始玩重制的 Final Fantasy Tactics.

其它

今年在前司干满八年后终于下定决心走出舒适区跳槽了。八年已经是我在同一个雇主那里的最长记录了。

两个猫都开始吃处方粮了，但是至少 Kaylee 拉稀的问题基本得到了控制，算是松了一口大气。

年底又买了个房，在 2025 最后一天拿到了钥匙。

What Ilya Sutskever, Satya Nadella, and Sam Altman think about AI progress in 2025

Bytepawn - Marton Trencseni — Wed, 31 Dec 2025 01:00:00 GMT

This article contrasts how Ilya Sutskever, Satya Nadella, and Sam Altman think about AI progress, from research and generalization, through infrastructure and economics, to agents, scaling, and societal impact.

Should I buy a company after visiting Victoria, BC?

🦉 olshansky 🦁 — Tue, 30 Dec 2025 23:03:10 GMT

What started as a tiny trip to Victoria turned into a deeper question about capital, optionality, and how to buy time.

Best of 2025

Obvious Bicycle — Tue, 30 Dec 2025 22:13:24 GMT

All my favourite things from this year

The Pro-life Position Leads to Dark Places

Rondam Ramblings — Tue, 30 Dec 2025 20:21:12 GMT

One of the things I did this year was to engage in one of the most ridiculously long Reddit discussion threads ever, and that is really saying something. That link doesn't even go to the beginning of the thread because the discussion chain was broken by a post that was deleted by my interlocutor, who goes by the pseudonym "uniformist". The discussion branched and ebbed and

Looking back at 2025

Lawrence Jones — Tue, 30 Dec 2025 17:00:00 GMT

Last year I wrote this from an empty office on New Year’s Eve. This year I’m in the boardroom between Christmas and New Year, back from a Pizza Union lunch, waiting for mulled wine to heat up in a Moccamaster because we’re not allowed a saucepan in the kitchen. There’s a handful of engineers half-working, half-chatting in the background. It’s a quiet week.

This is markedly better than last year.

In 2024 I said I expected to be “wrestling with AI” for another year. I was right. It was worth it.

The bet (January–March)
The push (April–September)
The product (October–December)
The team
Everything else
The hardest year
Looking ahead

Preread

For those fortunate enough to have avoided my internet presence, I’m a founding engineer at incident.io leading the AI team. My last year has been about building an ‘AI SRE’: a system that can debug production incidents for you, digging through logs, metrics, traces and historic incidents to tell you what’s gone wrong and how to fix it.

In this post I’ll talk about the ‘investigation system’ which is what does the debugging of incidents, and chats back to responders in their incident channel. I’ll also mention the @incident chatbot which responders can ask to take actions on their behalf or use to query things “what’s the error rate right now? does this support our theory that service X is the cause?”

AI SRE - the investigation interface and Slack experience

That should be enough about the product to understand, and some contextual markers for the company are:

Grew from 69 → 160 people, 20 → 45 in engineering
Substantially grew revenue
Series B in April: $62M at $400M valuation

And with that…

The bet (January–March)

Coming back from Christmas, the investigation system (what triggers at the start of an incident and tries to diagnose the issue) was working in a “prototype way”.

It could search for code changes, relevant Slack messages, past incidents, but making improvements was hard. At ~50 prompts all interacting with one another it was too easy to make a change in one place that broke the system elsewhere, and with only prompt-level evals (essentially unit tests) we didn’t have enough safeguards to allow scaling the team in headcount.

I’d spent the previous December making ad-hoc changes and hoping they’d work, but I was sorely missing tools that could quickly confirm the impact was good or catch if there were regressions. With us making a big bet on AI–the Series B already in motion–it wasn’t viable for just me to be working on this.

What that meant was a bit uncertain, as ‘tooling’ for AI systems was fairly nascent at the time. Pulling nouns out of thin air, I’d arrived at this idea of building ‘datasets’ that we could ‘backtest’ AI interactions against, with ‘graders’ that could score the interactions and ‘scorecards’ to track in which direction the scores moved.

AI maturity stages - from my LeadDev talk

I spoke about the AI ‘maturity’ scale at LDX3 later that year, which is what I spent January building. While uncomfortable pausing work on the actual product, it was a ‘slow-down to speed-up’ investment which I hoped would unlock more people being able to work on the investigation system in parallel.

The breakthrough moment came quicker than I expected, where the MVP backtest system helped make a change to PR searcher that meant in just an hour I improved precision and recall by ~20% and could prove that my change was responsible. It may not sound like much, but until now the changes we’d make were mostly intuitive, making tweaks that made sense theoretically but lacking the “it made this number go up!”. It was a deep relief to unlock a more robust workflow, and we immediately got Lisa and Rory involved in tuning the system.

Honestly though, a lot of this AI work is just making things up. There aren’t any great systems for building complex GenAI products because until now those products haven’t existed, so figuring out sensible approaches to testing and scaling a team was about taking approaches from other disciplines and refitting them to work for this new world.

Consequently, I was a bit nervous. Especially going into the Series B process when I was being interviewed by potential investors on how we’re building the AI product, it was very possible they’d laugh at how naive our approach was.

Happily, that turned out not to be the case! I must’ve spoken to tens of companies and experts familiar with AI development and felt pretty happy that every one of them was surprised at our level of sophistication. We had a system that was extremely non-deterministic, solving complex problems with multiple agents interacting, but we’d got to a place where changes could be made with confidence leaning on measurements we could trust. Apparently this was exceedingly rare.

Series B announcement - $62M to build AI agents

We continued to hill-climb on the investigation scores and improve our tooling, eventually taking a few days as a team to write-up a lot of what we’d learned, turning it into our Building with AI microsite alongside a feature in The Pragmatic Engineer. The whole team contributed, which felt like a good celebration of what we’d achieved, especially as the product itself wasn’t live with customers (which is usually where our team gets their buzz).

The bet on tooling paid off, and continues to. At this point it unlocked adding more people, but has since allowed us to substantially scale-out AI in the company.

And then we announced the Series B. And then we picked a date.

The push (April–September)

In late May we had the full company offsite in Greece - our first with half the company in the US and half in the UK. On the last day, tired after a lot of fun, I sat down with founder and leadership and for the first time seriously spoke about: what are we going to release? When do we show it? What do we actually demo?

At that point we had the investigation system (sometimes good, sometimes not) automated suggestions into channels, the chatbot for updates and questions. But nothing tied together into a cohesive product. This was a result of AI being so R&D heavy, where you don’t know what you’re going to build until you build it and see what works. So there was a lot of work before this felt like a real ‘product’.

We decided to target Sev0 San Francisco in September. It’s our yearly conference in our flagship city, and felt an appropriate moment to release AI SRE to the world properly.

The scope we landed on was ambitious: a fully live demo where nothing was faked. Trigger a real incident in our own production, get paged, kick off the investigation, let it find the causing PR, draft a fix, merge it, interact with the chatbot, build a post-mortem. The whole flow, live, in front of hundreds of people.

That meant we needed to get from “80% of the time it works” to “100% for a live demo.” That’s a big gap.

It was in August that we had a sit-down with the AI team and properly acknowledged how large that gap was. Given the importance of Sev0, we were looking for levers that could make sure we hit an amazing result, having already pulled most of them.

In a time like this, where you have a huge amount of work to do and a deadline to hit, the most reliable option is (unfortunately) just working more. Any arrangement like this is a two-way street and the company is required to support the team too: food in the office, overtime pay, taxi expenses, removal from interviews and other lower priority meetings. None of it was mandatory, but the importance of us nailing this was made clear.

I was nervous about this ask. The team were already working hard and we’d just added several new people - asking them to ramp up into a crunch felt tough, but the response was overwhelmingly positive. I was shocked at how it galvanised the team which was maybe a bit naive of me. This opportunity is really huge and that was obvious to me, and unsurprisingly the team around me felt the same. Not only that, but having the company expressly clear out any distractions or red tape and allow you to focus on work that really excites you, well. Apparently that’s something that resonates here.

We moved into a room at the end of the office - new desks, whiteboards on the walls, windows overlooking a park. Rory jokingly called it the “Swedish prison” (“still a prison, but quite nice”). I actively discouraged this but lost the battle when someone installed a flag.

The Swedish prison - our workspace during the Sev0 push

The ‘crunch’ began with ‘the great refactor’. We’d been building all sorts of AI features in a quick experimentation loop, but that meant the ideal structure of the codebase was something we’d deferred, leading to the majority of our AI code living in a single Go package called copilot with 500 files.

The team growing from ~3 to ~7 engineers, a package like that no longer works, as the blast radius modifying a single file is much harder to predict with everything tangled together. Merge conflicts are a horrible way to live, and ownership is hard in a setting like this (not to mention onboarding) so over July and August we restructured everything into an organised app/ai/* hierarchy with 25+ packages. It was a lot to do simultaneously with the Sev0 push, but it’s what enabled us to scale the team without everything falling over.

Leading up-to Sev0 the daily rhythm was: stand-ups covering each of the several on-going projects, and daily demo dry-runs with Pete where we’d build a friction log of everything that needed improvement. That would produce a backlog, then subgroups of 2-3 engineers would own a focus area and work from the backlog, holding themselves to account with backtests and scores. If we started with 80% correctness when querying the catalog, for example, that subgroup would own bringing it to 100% before we went out on stage.

You could see it getting better day by day, which was motivating.

Some of the debugging got strange. I remember testing whether the chatbot could see images as they were passed between LLM tool calls. You want to use novel pictures each time to avoid the LLM ‘cheating’ by reading your previous interactions and tricking you into thinking it was working.

At that point, working many hours a day late into the evening, you all end up in fits of giggles laughing at how ridiculous your job has become. The image of everyone tired in a room late at night, laughing at the absurdity of copying dog pictures into incident channels, that’s what engineering looked like this year.

Late nights debugging LLM vision

The demo at Sev0 SF went really, really well. Pete showed the live demo, then I did a ‘behind the scenes’ segment walking through the same investigation but showing our internal tooling - how we actually trust and evolve the system. Over 4.5 minutes, watching it go through all the investigation steps and arrive at conclusions about what the problem was. All of it worked. We were over the moon.

The audience included people from Amazon, Anthropic, Databricks, Docker, Etsy, Netflix, Uber. The feedback was overwhelming: “this is exactly what we want.”

We delivered exactly what we’d committed to at the offsite - that last day in Greece when we said Sev0 September is when we release this. It felt like we did a phenomenal job given all the constraints.

Sev0 SF product showcase - where we demoed AI SRE live

Afterwards, jet-lagged and exhausted, Martha, Rory, Shlok, Sam, Ed bumbled around San Francisco with me. We hiked Eagles Point. Tried to see the sea lions - they stunk. Attempted a baseball game but messed-up the timings. Scootered between drinks. Really fun, really exhausting, really worthwhile.

One moment I keep coming back to: Shlok joined as an intern during the craziest time, got onboarded onto all the AI stuff, contributed to the Sev0 demo, came to San Francisco, and saw his work presented on stage. As someone who wouldn’t be here if not for my internship at GoCardless, seeing the company grow into a place that can give that type of experience is quite emotional.

They say there are different types of fun, where ‘Type 2’ is challenges that become rewarding in retrospect. I’ve had a lot of that in my career, enough that I’ve become good at recognising when it’s happening at the time and appreciating it.

Perhaps that’s cheating, but I realised how much I’d miss it even when locked in the Swedish prison. Lots of memories.

The product (October–December)

For about 12 months I’d been telling Pete that we should hold off on telemetry (metrics, logs, traces).

My theory was that competitors were going deep on observability because they don’t have incident data. We do. Our platform is the system of record for everything that happens during incident response - alerts, code changes, postmortems, Slack messages. That’s data no one else has, and I thought we should exhaust what we could do with it before chasing telemetry connections.

I was increasingly uncomfortable with this position. As time went on and competitors invested heavily in their observability integrations, I started to feel like I was wrong. But we kept pushing on the investigation brain - what we call the ‘assessment’ step - modelling chains of causation, structuring findings more robustly, introducing thinking models in various places.

In November, something clicked. The changes we’d made drove our RCA quality scores from ~60% to 75-80%. At that point, the feedback from customers changed: “This is really good. I just want you to have access to more data. It’s not that your reasoning is wrong - it’s that you can’t see the logs.”

Now it made sense to start on telemetry.

The good thing about having held off is that I’d been thinking about the architecture for almost a year. I sat down and realised we could build this out really quickly. What followed was about four weeks of me trying to spike out a system that could plug into any data source - logs, metrics, dashboards, traces, even SQL databases - and expose them behind a ‘telemetry agent’ that understands how to use them.

One driving principle of all our AI SRE so far has been to make it work generally, without requiring customers to give specific instructions or customise the prompts. Telemetry should be the same: you plug in a data source, the system compiles information about what’s in there, combines it with a language specification for how to query it, and learns how to use it effectively. When an incident happens, it already knows what data is available and how to get at it. Zero custom prompting per customer - it generically understands how to use their systems.

After building the initial telemetry system with Loki + Prometheus + Tempo, the team managed to get Datadog (logs, metrics and traces) up and running in just a week. When we dialled it in for one of our design partners, it took two hours to fix-up some teething problems and see their investigation scores jump.

The results have been kind of incredible. The team’s Slack is now full of messages like:

“It beat me by about 6 hours” - on finding a foreign key constraint violation from logs
“There was no dashboard for this, it just found it” - on a batch job that silently stopped running
“Do you know how hard it’d be to find that in a trace on mobile?” - on finding a date bug where the iOS app requested schedule entries for year 2061
“The fact that it’s able to validate this is fucking insane”

Team reactions when AI SRE finds something good

In our production incident account, we now have AI SRE connected to Grafana (Loki, Prometheus, Tempo), GCP logs, dashboards, and more. When our Cloud SQL has a deadlock, it correlates the alert logs with deadlock logs and lock wait lists from cloud logging. It’s able to combine these sources into a picture that’s more complete than anything we’ve had before.

Honestly, I use the telemetry agent more than I use Grafana now. It’s better than me at formulating the right LogQL or PromQL query, and being able to tie that immediately into GCP cloud logging - then feed it back into the investigation to refine what we think is going wrong - that’s game-changingly good.

Using AI SRE for general production questions, not just incidents

By December we’d hit ~90% RCA quality across 50 representative incidents. Design partners are starting to say “this is seriously useful” and our job over the next couple of months is to get them to “I cannot live without this.”

Reflecting on this: I think I’ve been messing around with how to build these kinds of abstractions for most of my professional career. pgsink (an open source ETL project I built years ago), the alert system abstractions at incident.io, the engine programming language that powers our conditional logic. Building systems like this is my biggest strength as an engineer, and I’m really excited about what this framework will allow us to do.

It’s made me feel better about holding off as long as we did, now we can see how fast we can build on stronger foundations.

The team

In January, the AI team was me, Lisa, and Rory Malcolm. By December, we were 18 engineers.

Growing a team 6x while shipping a product is hard. Growing an AI team 6x is harder, because AI work doesn’t fit normal frameworks.

You can’t scope it in advance - you’re often trying to do something you’re not sure will work, so you prototype until something emerges. And our normal processes like ‘polish parties’, where you walk through the product click-by-click and roast the flow, fall short because AI might work for one use case and fail terribly for 30% of others. If you created a pretty AI interaction where the AI is totally wrong, no one cares. It might even offend them more.

What worked instead was what I described in the push: subgroups owning specific parts of the system, measured by scores, with full autonomy on how they hit 100%. The eval infrastructure we built in January made this possible, and without it, we couldn’t have parallelised the work.

By December the team had settled into three themes: the ‘brain’ (the core investigation engine), integrations (Datadog, external status pages, IDE distribution), and design partners (proving AI SRE at scale with companies that have thousands of engineers and services).

But broader than just the AI team, there are some moments I keep coming back to:

QCon in April

I was there to support Martha and Alicia who were both giving talks.

QCon is extremely technical - most speakers have published respected technical books. Martha’s talk was about the reliability work we’d done together on the on-call product the previous year: load testing, production drills, all the things I’d learned as an SRE at GoCardless. She’d never done this kind of work before, but she learned it and delivered a talk that was incredibly practical and full of hard-earned lessons.

On-call has averaged four nines availability since launch, which is notable for a product that’s only a year old and already a third of our business. Watching her on stage, I kept thinking about the fact that I joined this company when it was just the three founders, Lisa and I. Now it’s 160 people, and we have engineers speaking at conferences like QCon with authority and confidence.

Anthropic dinner (and others)

I went to an Anthropic engineering leadership dinner in November with a collection of other top company leaders in London.

I’d accepted last minute and hadn’t clocked it was a fancy place in Mayfair - I turned up in a scruffy t-shirt and jeans, looking extremely out of place.

Despite this, it was a real pinch-me moment as people noticed my incident.io namebadge (misspelled, if I remember correctly) and were effusive about our brand and what they’d seen of it. We keep getting comments about being the place to work in London which is a proud moment for everyone who’s helped build the culture here, but it was particularly noticeable in a room full of such high profile companies.

100% offer acceptance

I’m overjoyed that we went all-in on internships and graduate roles this year and have made offers to 5 of each, with all 10 offers being accepted.

That’s crazy in any circumstance but is even wilder considering we had thousands of applicants to both roles. The candidates are the best in the entire country with every company to pick from, but a huge effort to run an exceptional recruitment process has meant they’ve chosen incident.io as the place they’ll start their careers.

It’s not just junior roles, though: we’ve hired about 20 engineers this last year, and the new hires we’ve made are all exceptional. This is the strongest team I’ve ever worked in, full of kind, hard-working and talented people who make working here a joy.

Everything else

Beyond the product work, I’ve been busier externally than any year before. A quick round-up:

Talks

LeadDev LDX3 (June) - “Becoming AI Engineers” - my first big conference talk, covering maturity stages, tooling, and the human side of AI systems
Sev0 SF & London (September/October) - “Behind the scenes” product showcase segment

Podcasts

I’ve been doing more podcasts this year, trying to speak about AI and topics on engineering culture.

AI Adoption Playbook (May) - Building AI that investigates outages, scorecard-driven development
Adventures in DevOps (October) - Ephemeral runbooks, dynamically generated from PRs and past incidents
IT Visionaries (November) - “90% of AI Demos Fail” - the gap between demos and production
Product Talk with Teresa Torres (November) - “When AI Becomes Your SRE” - with Ed Dean

Writing

As is tradition, I’ve done much less writing this year than I would like, but am very proud of our AI microsite and featuring in the Pragmatic Engineer.

Beyond the AI MVP (February) - What it really takes to ship AI products
You Don’t Need Python (February) - Building AI in Go, why static typing helps
AI Innovator’s Dilemma (March) - Why startups have an advantage in AI
Why Change Role to AI Engineering (April) - Career pivot, what the role actually means
Plus the Pragmatic Engineer feature and Building with AI microsite launch in March

The hardest year

I’ve worked a lot this year. More than any year before, in this role or otherwise, by a margin. I’m not complaining - I knew what I was signing up for joining a start-up like this – but I want to be honest about the experience instead of pretending it was an easy ride.

AI work doesn’t fit the normal frameworks. You can’t scope it properly because you don’t know what’s going to work until you try it. That makes it hard to forecast, hard to communicate to stakeholders, hard to give PMs and designers something to work with. For long stretches I’d go heads-down building something that might not pan out, then surface weeks later with a prototype and realise I’d left other fires to burn in my absence.

That oscillation is challenging. And the competition hasn’t made it easier - everyone and their grandmother is building an AI SRE nowadays, from well-funded startups to megacap companies like Datadog. There were periods where I genuinely wasn’t sure if we were ahead or behind, and I felt a large amount of responsibility for making sure we landed.

I think what made it manageable was having something to show for it. The Sev0 push was brutal, but we shipped. The telemetry work was intense, but customers are now saying things that make it feel worthwhile. If I’d worked this hard and we’d shipped something mediocre, I’d be in a different headspace right now.

Did I manage it better than 2024? Honestly, yes. Last year I was wrestling with whether AI would work at all. This year I was wrestling with how to make it great. That’s a better problem to have, even if it’s still hard.

The team helped. Having people around who are just as invested, who you can laugh with at 10pm in the Swedish prison while debugging whether an LLM can see a picture of a dog - that makes the difference between miserable and memorable.

Looking ahead

No one has quite cracked AI SRE yet. I think we’ve almost done that.

We have 5 design partners - multi-billion dollar companies with thousands of engineers - running real incidents through AI SRE. We’re at ~90% RCA quality. The telemetry system is working. The team is 18 engineers with a clear path to growing further.

Next year is when the rubber hits the road: actually deploying and selling this at scale. That’s a different kind of challenge to what we’ve faced so far. Less R&D uncertainty, more execution against a defined product. Scaling what works rather than building from scratch.

I don’t think we’ll have the same intensity as this year. Not because we’ll work less, but because the shape of the work changes. The foundation is there now and what comes next is capitalising on that, and if our design partners continue saying what they’re saying, we might have lightning in a bottle.

I’m again reminding myself to be appreciative of the journey. Each year at incident.io has been the most significant and exciting of my career, and that continues. I got to build something genuinely new this year with people I really like working with, and that’s not something to take for granted.

If you’d told me in January where we’d be by December - the product, the team, the external recognition - I’d have been sceptical, but we delivered on almost everything we set out to do.

So what’s the prediction for 2026? We’ll know by this time next year whether AI SRE is truly the product that changes how companies run incidents. I think it will be. And if I’m wrong, it won’t be for lack of trying.

See you then.

2025: Another SaaSy Year In Review

Stay SaaSy — Tue, 30 Dec 2025 14:59:22 GMT

It was another a very good year.

2025

trv.rs — Tue, 30 Dec 2025 14:08:00 GMT

This was a pretty wild year all 'round. Birth of a child, caught in a layoff, freelancing, working in a startup.

Spiritual Life

I've been keeping track of prayer requests this year. As of this writing I have recorded sixty-one specific answers to prayer this year. Praise the Lord for his provision!

I added kneeling prayer once a day to my habits… targeting the time I'm usually most tired and prone to irritability. I think that's helped. My personal quiet time has been very fractured and infrequent. I've been a little more consistent at having family worship at the table.

That being said, I have felt the Lord's hand and protection through the big waves. In so many ways this year has been a dark mirror of 2020: political unrest, job change, pregnancy, much discussion and stress… but rather than being pulled away from the Lord and pulled apart in marriage, we have been strengthened and upheld.

Relationships

Because of chaos and baby, we didn't take too many trips this year… just three wild trips to the beach.

We've had a lot of folks in our home for board games and dinner, and that's been a big joy that we want to do more of next year.

Another big answer to prayer is that we are both enjoying our kids more than ever. They haven't been easier to deal with, I have just been granted more grace to enjoy them.

Health

Equal victories and defeats here.

FitBod continues to be my workout buddy.

After a short weight loss before baby arrived, I've shot up to 180lb and stayed there since June. Some of that was post-birth weight gain, but some of that has been some re-building of new muscle. I bought my first t-shirt in size L this year, and it's because of my shoulders not because of my gut. 💪

I tapered off Zyrtec, and have been six months or so without my daily dose. Doesn't seem to have affected my sinuses at all.

My skin stuff and gut owing to stress has continued to be a problem, but not as bad as previous years. I think that the smartwatch's input on my sleep has been a good lag metric to help me stay healthy.

My Morton's Neuroma hasn't really improved in a year of PT. I'd say I'm about 70% faithful to do the physical therapy, but I hoped to be farther along. I am starting to consider surgery… mobility is a big deal. I was really sad that for the first time in five years I was unable to run the 8k race near my house. I really have to get that fixed.

Creating

I only published 20 blog posts, less than half of last year.

My writing habit got severely curtailed by both the birth of a child, loss of a job, and pursuit of a new one. I still have written a fair amount (I've created 1100+ files in my wiki!) it just hasn't made it's way out to the blog.

Scrolling through the list of wiki notes… there's a lot of thinking about work, about personal growth, about people that I'm praying for, and of course, AI.

(I have a couple larger essays stuck in my system again… maybe I'll get a chance to polish them up over the break, or at least find a format where I'm ok with publishing them imperfect.)

I did spend some time updating the blog itself… adding slashpages and updating some old ones. The /blogroll and /uses get updated relatively often, and I usually update /now when I switch books.

I've continued to double down on nix as a strategy and am loving it. It was a huge blessing to have that tool in my arsenal when I wound up consulting as a software engineer for ~6 months. The fact I could update my computer without fear of destroying a project's configuration… wonderful.

While I use AI a good bit for work, I still try to write my prose and code by hand. No good reason. Just sharpening a tool, and hopefully my mind.

Sketchnoting

I continue to sketchnote weekly sermon entries. I also did sketchnotes for the dev track of a local tech conference. Looking back at this year I realized that I've relied a bit too much on speechbubbles, and I'd like to do more diagrams and visual storytelling.

I've also started (very recently) a weekly sketching habit. I've not been utterly faithful to it, but it's been nice to sit and just see for thirty minutes. I'm super thrilled that my kids sit with me and show me their results.

Reading

This year I changed my lead indicator of reading to "books I have started" to try and allow myself to drop a book that "gets stuck." By this metric, I started 26 books, finishing 21.

Some highlights:

Polostan by Neal Stephenson: In a world of change, spies navigate the rising power of communism and the new science of the atomic age.
Teach Them Diligently by Lou Priolo: A look at raising children through the light of 2 Timothy 4:2.
Consider The Lilies by Jonny Ardavanis: Extinguishing anxiety by looking into the overwhelming goodness of our Father God.
Piranesi by Susanna Clarke: Wandering a strange house, an optimistic journal ponders the most important questions.
How to Lead Your Family by Joel Beeke: Exhorting men to pattern our lives after Christ in his roles as prophet, priest, and king in our homes.

My new Boox Palma has really helped… I really love KOReader.

I've listened to less podcasts over the year… in part because of realizing how vulnerable my mind is to words. Some standouts from my subscriptions:

Gospelbound has been a great source of books for my queue.
Dwarkesh has kept me apprised of AI thought, although I find myself disagreeing with his positions more over the year. (I find his comparisons of baby's learning styles to LLM training sequences utterly ridiculous, and I fundamentally disagree with his concept of what is knowledge.) I do really admire his curiosity and tenacity.
I don't listen to every episode of Presbycast, but I do listen to every episode of their Fathers and Brothers collection.

I've been continuing to use Refocus to block all social media, shopping, and distractions for much of the year. That has contributed to the growth of my /blogroll.

Work

Ironically, I had set this year's theme as "Look for Work," and boy did that hit with a vengeance.

The original meaning for me was partly about finding my next job, but also about just avoiding laziness: to have a mindset that always looks for the next thing to do… but when the layoff struck it collapsed down to finding a paycheck.

Even before the layoff, I've been beset with the eternal question of "what do I want to do when I grow up?" UX or programming? Management or IC? How does AI change any of this?

I'm still working on that. 🤷

2026

I'm hoping to spend some time with my wife planning the next year… at the moment the time has been coming too fast and furious so I haven't set a good Theme for 2026.

One thing is for sure, I know that the Lord will display his infinite faithfulness and love even more fully in this year than the last. Happy new year!

The Science of Optimal Experience: Understanding Flow with Orin Davis

Zappable — Tue, 30 Dec 2025 13:45:42 GMT

The latest podcast episode covers Flow with Dr.

Still using Firefox — but not because of its vision

Igor Kulman — Tue, 30 Dec 2025 08:00:00 GMT

For years I have been using Firefox as my primary browser. Not out of ideology or nostalgia, but because it did the job well enough and stayed out of the way. Lately, however, I have been increasingly uncomfortable with where Firefox is heading — and yet I am still using it. This post is about why. Firefox’s new direction In December 2025, Mozilla made it clear that Firefox is entering an “AI browser” phase.

The Books of 2025

Eddy Luten — Tue, 30 Dec 2025 08:00:00 GMT

This year I read a surprising (to me) amount of books: 21 according to my notes, 6 more than last year. Here they are, listed chronologically in reading order. I’ll also list my favorite reads towards the end of the post.

Siddhartha

Arun Mani — Tue, 30 Dec 2025 02:00:00 GMT

A story of discovering one's own enlightenment.

My 2025 review as an indie dev

xenodium.com @alvaro — Tue, 30 Dec 2025 02:00:00 GMT

In 2024, I took the leap to go indie full-time. By 2025, that shift enabled me to focus exclusively on building tools I care about, from a blogging platform, iOS apps, and macOS utilities, to Emacs packages. It also gave me the space to write regularly, covering topics like Emacs tips, development tutorials for macOS and iOS, a few cooking detours, and even launching a new YouTube channel.

The rest of this post walks through some of the highlights from 2025. If you’ve found my work useful, please consider sponsoring.

Off we go…

Launched a new blogging service

For well over a decade, my blogging setup consisted of a handful of Elisp functions cobbled together over the years. While they did the job just fine, I couldn't shake the feeling that I could do better, and maybe even offer a blogging platform without the yucky bits of the modern web. At the beginning of the year, I launched LMNO.lol. Today, my xenodium.com blog proudly runs on LMNO.lol.

LMNO.lol blogs render pretty much anywhere (Emacs and terminals included, of course).

2026 is a great year to start a blog! Custom domains totally welcome.

A journaling/note-taking app that feels like tweeting

Sure, there are plenty of journaling and note-taking apps out there. For one reason or another, none of them stuck for me (including my own apps). That is, until I learned a thing or two from social media.

With that in mind, Journelly was born: like tweeting, but for your eyes only. With the right user experience, I felt compelled to write things down all the time. Saving to Markdown and Org markup was the mighty sweet cherry on the cake.

Let's learn Japanese

As a Japanese language learning noob, what better way to procrastinate than by building yet another Kana-practicing iOS app? Turns out, it kinda did the job.

Here's mochi invaders, a fun way to practice your Kana

A new Emacs-native AI/LLM agent (powered by ACP)

2025 brought us the likes of Claude Code, Gemini CLI, Goose, Codex, and many more AI/LLM CLI agents. While CLI utilities have their appeal, I wanted a native Emacs integration, so I simply ignored agents for quite some time.

I was initially tempted to write my own Emacs agent, but ultimately decided against it. My hope was that agent providers would somehow converge to offer editor integration, so I could focus on building an Emacs integration while leveraging the solid work from many teams producing agents. With LLM APIs historically fragmented, my hope for agent convergence seemed fairly far-fetched.

To my surprise, ACP (Agent Client Protocol) was announced by Zed and Google folks. This was the cue I had been waiting for, so I set out to build acp.el, a UX agnostic elisp library, followed by an actual client: agent-shell.

I'm fairly happy with how agent-shell's been shaping up. This is my most popular package from 2025, receiving lots of user feedback. If you're curious about the feature-set, I've written about agent-shell's progress from early on:

chatgpt-shell improvements

While agent-shell is the new kid on the block, chatgpt-shell received DeepSeek, Open Router, Kagi, and Perplexity support, in addition to a handful of other improvements and bugfixes.

A new YouTube channel

While most of what I share usually ends up as a blog post, this year I decided to try something new. I started the Bending Emacs YouTube channel and posted 8 episodes:

Enjoying the content? Leave me a comment or subscribe to my channel.

My decade with org (Emacs Carnival)

While I enthusiastically joined the Emacs Carnival, I didn't quite manage monthly posts. Having said that, when I did participate, I went all in, documenting my org experience over the last decade. Ok well… I also joined in with my elevator pitch ;)

Awesome Emacs on macOS

While migrating workflows to Emacs makes them extra portable across platforms, I've also accumulated a bunch of tweaks enhancing your Emacs experience on macOS.

EverTime for macOS

While we're talking macOS, I typically like my desktop free from distractions, which includes hiding the status bar.

Having said that, I don't want to lose track of time, and for that, I built EverTime, an ever-present floating clock (available via Homebrew).

A new time zone Emacs package

Emacs ships with a perfectly functional world clock, available via M-x world-clock, but I wanted a little more, so I built time-zones.

Also covered in:

A new WhatsApp Emacs client

For better or worse, I rely on WhatsApp Messenger. Migrating to a different client or protocol just isn't viable for me, so I did the next best thing and built wasabi, an Emacs client ;)

While not a trivial task, wuzapi and whatsmeow offered a huge leg up. I wanted tighter Emacs integration, so I upstreamed a handful of patches to add JSON-RPC support, plus easier macOS installation via Homebrew.

Details covered in a couple of posts:

Spiff that shell up

While both macOS and iOS offer APIs for generating URL previews, they also let you fetch rich page metadata. I built rinku, a tiny command-line utility, and showed how to wire it all up via eshell for a nifty shell experience.

With similar eshell magic, you can also get a neat cat experience.

At one with your code

I always liked the idea of generating some sort of art or graphics from a code base, so I built one, a utility to transform images into character art using text from your codebase. Also covered in a short blog post.

Emacs can trim your videos too

Emacs is just about the perfect porcelain for command-line utilities. With little ceremony, you can integrate almost any CLI tool. Magit remains the gold standard for CLI integration.

While trimming videos doesn't typically spring to mind as an Emacs use case, I was pleasantly surprised by the possibilities.

Landing Emacs patches upstream

While I've built my fair share of Emacs packages, I'm still fairly new at submitting Emacs features upstream. This year, I landed my send-to (aka sharing on macOS) patch. While the proposal did spark quite the discussion, I'm glad I stuck with it. Both Eli and Stefan were amazingly helpful.

This year, I also wanted to experiment with dictating into my Emacs text buffers, but unfortunately dictation had regressed in Emacs 30.

Bummer. But hey, it gave me a new opportunity to submit another patch upstream.

Ready Player improvements

Ready Player, my Emacs media-playing package received further improvements like starring media (via Emacs bookmarks), enabling further customizations, and other bug fixes. Also showcased a tour of its features.

GitHub activity

Commits: 1,095
Issues created: 37
PRs reviewed: 106
Average commits per day: ~3

New GitHub projects

EverTime - An ever present clock for macOS
acp.el - An ACP implementation in Emacs lisp
agent-shell - A native Emacs buffer to interact with LLM agents powered by ACP
diverted - Identify temporary Emacs diversions and return to original location
emacs-materialized-theme - An Emacs theme derived from Material
homebrew-evertime - EverTime formula for the Homebrew package manager
homebrew-one - Homebrew recipe for one
homebrew-rinku - Homebrew recipe for rinku
one - Transform images into character art using text from your codebase
rinku - Generate link previews from the command line (macOS)
time-zones - View time at any city across the world in Emacs
video-trimmer - A video-trimming utility for Emacs
wasabi - A WhatsApp Emacs client powered by wuzapi and whatsmeow

Blog posts

Hope you enjoyed my 2025 contributions. Sponsor the work.

Pinyin Chart

june.kim — Tue, 30 Dec 2025 02:00:00 GMT

🎄 Advent of EIP Day 7: Switchboards, Webhooks, and Everything In Between

James Carr — Tue, 30 Dec 2025 02:00:00 GMT

Before computers, we had switchboards. An operator would receive your call, ask who you wanted to reach, physically connect your line to theirs with a patch cable, and you’d talk. When you hung up, the connection was torn down. Request-reply in its purest form: synchronous, blocking, one conversation at a time. The telephone system evolved. Direct dialing replaced operators. Trunk lines multiplexed thousands of calls. Voicemail let you leave a message with a return address (your number) so someone could call you back later.

2025-12-30

ho.dges.online — Tue, 30 Dec 2025 02:00:00 GMT

Goodbye 2025.

12 Board Games for 2 Players

The David Brownman Blog — Tue, 30 Dec 2025 02:00:00 GMT

Short reviews of 12 games when played with exactly 2 people.

Read the whole thing.

Tribute to Appa

ST — Tue, 30 Dec 2025 02:00:00 GMT

What They Can't Teach You At Cybersecurity School

Security Wale — Tue, 30 Dec 2025 01:09:52 GMT

Your degree gave you the science. The industry demands the art.

2025-12-29-001

Srijan Choudhary, all posts — Tue, 30 Dec 2025 00:20:00 GMT

Faced a failing disk in my raidz2 ZFS pool today. Recovery was pretty simple: Asked the service provider to replace the disk Find new disk ID etc using: lsblk -o NAME,SIZE,MODEL,SERIAL,LABEL,FSTYPE ls -ltrh /dev/disk/by-id/ata-* Resilver using: sudo zpool replace lake Watch status using: watch zpool status -v Re-silvering is still ongoing, but hopefully …

SoftBank To Buy Data Center Firm DigitalBridge For $4B

The Techee — Mon, 29 Dec 2025 19:49:52 GMT

Japanese tech conglomerate SoftBank (TYO: 9984) has struck a deal to acquire DigitalBridge Group (NYSE: DBRG), a U.S.-based data center and telecoms infrastructure investor. SoftBank will pay $16 in cash per share, totaling $2.9bn. It’ll also assume DigitalBridge’s liabilities, pushing the deal’s value to $4bn. SoftBank’s offer represents a 15% premium to DigitalBridge’s share price […]

The post SoftBank To Buy Data Center Firm DigitalBridge For $4B appeared first on The Techee.

Societal changes since 1850s

Unremarkable thoughts — Mon, 29 Dec 2025 18:18:56 GMT

To get an idea of the upcoming changes due to AI, and the automation/delegation of knowledge work, we can look at what happened after the automation/delegation of manual labor for many people and at least in big part. This change happened in much slower pace than what is projected of AI. Admittedly, there were also […]

Why I Did Buy a Tesla

Tynan.com — Mon, 29 Dec 2025 18:12:13 GMT

About five years ago I wrote about why I chose to buy a BMW i3 instead of a Tesla like everyone else. I still love the i3 and think that it was the right choice at the time, but things have changed! A lot of my complaints about Tesla are still true. I really hate […]

Dev lifecycle improvments with AI

Ananth's Reflections — Mon, 29 Dec 2025 15:56:07 GMT

What can LLM agents help with in your coding lifecycle

If you care about security you might want to move the iPhone Camera app

John Graham-Cumming's blog — Mon, 29 Dec 2025 13:59:06 GMT

There's a quirk in the iPhone Camera app that can drive a security conscious iPhone owner crazy: if you touch your finger on the Camera app icon without actually opening the app, the camera starts operating. That causes the little green dot indicator on the iPhone to turn on and then after a few seconds disappear. This can easily make a security-conscious iPhone user worry that some app is nefariously using the camera.

Because touching the Camera app icon without opening the app is enough, it's easy to activate the green dot while swiping between screens or even just holding your phone. This was driving me nuts and I thought some app was using the camera when I didn't want it to.

I enabled Apple's App Privacy Report (under Privacy and Security) in Settings and, sure enough, it confirmed that the little green dot was happening because the camera was being used by the Camera app. Merely swiping while accidentally touching the Camera app's icon was enough to add an entry in the App Privacy Report.

The solution was moving Camera app away from where I was liable to brush it with my fingers or thumb. That reduced the errant green dots to almost zero and reassured me that nothing untoward was happening.

One of the big problems in security is people get used to odd behaviour they can't explain and end up overlooking a real problem masked be the things that "always happen". The accidental green dots could have been hiding actual nefarious use of the camera. Better to be tidy and eliminate the false positives.

(I previously used the term "hover" for what I was experiencing and that was causing confusion. This happens if you touch the Camera app icon without actually opening the app.)

Quick tip: Adjusting and inject content into tinyMCE with WordPress

Jaime Martinez — Mon, 29 Dec 2025 13:57:59 GMT

So I have a very activly maintained project that still relies on a tinyMCE here and there. And I needed to process some text and after an AJAX request inject it back into a textarea/tinyMCE field, but couldn’t get it to work. Which was a bit weird, because after calling window.tinymce.editors in de browser console […]

The post Quick tip: Adjusting and inject content into tinyMCE with WordPress appeared first on Jaime Martinez.

The Year of the 3D Printed Miniature (And Other Lies We Tell Ourselves)

matduggan.com — Mon, 29 Dec 2025 13:19:30 GMT

3D printing and miniatures as a case study in how tech misses what users actually want

The Unmade Bed by Françoise Sagan

Apurva Shukla's RSS Feed — Mon, 29 Dec 2025 04:19:12 GMT

⭐ ⭐ ⭐ ⭐ ⭐ I didn’t know what to expect when I picked this book up from my local library. At first, I was intrigued by the orchid on the…

After "AI": Anticipating a post-LLM science & technology revolution

Aditya Athalye's Eval/Apply Blog — Mon, 29 Dec 2025 02:00:00 GMT

I, for one, welcome the coming age of the post-LLM-datacenter-overinvestment-bust-fueled backyard GPU supercomputer revolution.

Some flexibility with Go’s sumdb

ENOSUCHBLOG — Mon, 29 Dec 2025 02:00:00 GMT

I noticed this a year or two ago, but forgot to write it up back then.

Caves of Qud: A review

Matt Keeter — Mon, 29 Dec 2025 02:00:00 GMT

What I Actually Want To Say in Tech Interviews

Nelson Figueroa — Mon, 29 Dec 2025 02:00:00 GMT

Honest answers to common interview questions in the tech field.

Another Site Rewrite

The David Brownman Blog — Mon, 29 Dec 2025 02:00:00 GMT

The why and the how behind my latest site rewrite.

Read the whole thing.

Beating myself at chess

Schemescape — Mon, 29 Dec 2025 02:00:00 GMT

Or: programming a chess AI without any preparation whatsoever.

How to install Firefly III on FreeBSD

David Schlachter — Sun, 28 Dec 2025 21:27:00 GMT

Installing personal finance manager Firefly III on FreeBSD.

Bypassing a clever CD-check

David Schlachter — Sun, 28 Dec 2025 19:09:00 GMT

Decompiling to understand how a CD-check was implemented in an old program.

📗 Breakneck: China’s quest to engineer the future, by Dan Wang

Ernest Oppetit — Sun, 28 Dec 2025 11:45:00 GMT

I’ve been following Dan Wang for years, and read a couple of his annual letters about China. When I saw his first book was coming out, I jumped on it as I have always found his approach really interesting. He mixes policy, societal and political analysis with very ‘on the ground’ first-hand observations about life […]

The New Whale Chase: Drones, Hydrophones, and a Father-Son Project

Greg Herlein — Sun, 28 Dec 2025 11:00:01 GMT

After two years of false starts with the Bristlemouth platform and permit headaches, I’m revisiting my whale song project with a completely different approach: semi-autonomous floating drones. The regulatory landscape has forced a rethink, and honestly, it might lead to something better.

Interessant3 #173 | UK Net Migration, Pay Transparency Laws, Geography & Logistics in WWII

Interessant3 — Sun, 28 Dec 2025 10:00:55 GMT

Three Interesting Things for W/C 2025-12-21

2025 In Review: The Year AI Changed Everything

Greg Herlein — Sun, 28 Dec 2025 10:00:01 GMT

Looking back at 2025, one theme dominates: AI agentic programming went from novelty to necessity. This year transformed how I think about software development, career advice, and even my personal hardware projects. Here’s what I wrote about, what I learned, and what I expect in 2026.

My Vibe Coded Projects in 2025

Beetle Space — Sun, 28 Dec 2025 10:00:00 GMT

This was my first year using AI coding tools. I’m often asked what I use AI coding for outside of work. Here I document what I’ve built with AI.

When I say “AI coding”, I’m excluding asking a chatbot for code and copy/pasting it into a …

Books I read in 2025

Nicola Iarocci — Sun, 28 Dec 2025 08:36:24 GMT

I read 35 books, or 10726 pages, in 2025. A remarkable step up from the previous year. I have not read so many books since 2015 (36), and I never read so many pages before. Having read a few comic books helps pump up the stats, I reckon, and I suspect switching to ebooks played a role, too, as reading is more accessible than ever.

I bought a first-edition Kindle back in the day, but never got around to using it much. After a few attempts to like it, it ended up in a drawer. Fast forward to 2025, I gave myself a second chance and got a Kobo Clara BW, a device I’m digging a lot. Yes, every time I finish an ebook I liked, I’m sad I cannot shelf it, but the advantages are many that I don’t think I’m going back to paper books anytime soon. There will be exceptions, I’m sure, but the norm will be ebook first.

2025

Studiofreya SSG Site — Sun, 28 Dec 2025 02:00:00 GMT

A post in 2025!

Kytice

Vít Baisa — Sun, 28 Dec 2025 02:00:00 GMT

sbírka básní

Mini Solar

tasuki’s blog — Sun, 28 Dec 2025 02:00:00 GMT

2025-12-28

ho.dges.online — Sun, 28 Dec 2025 02:00:00 GMT

Backpack Quest

The David Brownman Blog — Sun, 28 Dec 2025 02:00:00 GMT

My journey to find the perfect all-purpose daily driver backpack.

Read the whole thing.

Post-mortem, 2025 Edition

Ghettos of Abu Nawas — Sun, 28 Dec 2025 02:00:00 GMT

Post-mortem, 2025 Edition

1. Travel
2. Work
3. Learning
4. Life

Damascus, Jan 2025.

Another year, another performance review season to procrastinate on. I felt like I largely locked in this year on work, so the scorecard is:

1. Travel

In January I went to Syria, spending about a month there and bopping around Sayyida Zaineb. The experience was incredible, especially only a month after the fall of the Assad Regime—plus I had the opportunity to visit Aleppo and Lattakia.

Visiting Iraq (again) was also amusing. In the winter, there was 24 hours of government electricity, which itself was a shocker. I saw old friends in Erbil, and even a weird boxing match series in Ainkawa:

BXF (Babalyon X Fighting)

In May I went off to Algeria for a week, where I was charmed by the mosaics and annoyed by the lack of shisha. This was my first trip to Algeria, and really my first exposure seriously to the Maghreb. I'm quite keen on going back, as it's substantially different than Arab culture in the Mashriq.

El Salvador was also an interesting trip, I relaxed, worked through a small earthquake, and also spent quite a bit of time learning about Romero and thinking about saints. It surprised me with how much depth it had. The nightlife was a little dull, but I enjoyed having a tropical place to focus, work, and think.

2. Work

This year was really filled with work. Many 60 hour weeks, and I spent a significant amount of time getting up to speed on operations for WA and writing Erlang. Towards the end of this year, I'm happy to say I've mostly succeeded, I'm able to pick up most aspects of WhatsApp as an org and navigate and drive impact. I've been on an absurd number of outages this year, and I've seen all sorts of weird things break in WA¹.

One of our funnier outages even made it to the Linux Plumbers Conference this year, where the sched_ext mechanism for providing external schedulers, using the lavd scheduler, caused conflicts with CPU affinity and wreaked havoc on my tail latencies.

See https://www.youtube.com/watch?v=KFItEHbFEwg&source_ve_path=MTc4NDI0 for the full talk.

Honestly this constant firefighting has gotten me feeling a little burned out. In February I'll be transitioning to a role on HHVM Server, where I'll be working on the JIT and platform for HHVM, which has reinvigorated me a bit.

There's a big AI push at Meta currently, where we're heavily being encouraged to use as much AI as possible. I find Claude Code useful, but I've personally gone through the curve of inflated expectations and then the trough. I've seen people submit some real AI slop for me to review, forcing me to be the first line of quality control, but Claude Code also has made me much more productive in areas of programming I wouldn't have devoted time to before, such as Javascript. I now don't really worry about writing Javascript or having to learn React, or learning the latest Python package manager².

I'm still not quite sure how I feel about AI. The environmental impact I actually don't quite believe as much as the media hypes it up, but I do feel like it is pulling the ladder up behind us, removing the need for junior engineers. I feel like a thief who's made it past state lines, where I can efficiently guide the robot through doing tasks. If I was a junior engineer, I'd find it very difficult to resist the urge of using the robot for everything.

AI is an excellent study buddy. It's useful for reframing my thoughts, and it excels as a vague "vibe based" search engine. I feel like the Oxide RFD on LLMs accurately summarizes my experience with it: it's genuinely a transformative tool, but we need to be wary of how it impacts learning. It's sufficiently lowered the bar for learning new technologies, but I am unsure if I trust it with building serious products. For simpler codebases, I think it is excellent. For other codebases, I think I'd like to use it to churn out scaffolding more than anything else.

Despite all the hubbub about vibe coding, I find myself most efficient with the LLM when I understand the system and I just need the encantations for gluing things together. For example, our CLI tool at WhatsApp is written in Rust. Claude is quite good at writing a lot of Rust, but whether it's good Rust is a different question, as it seems to heavily favor clone() and pass by value. However, for a CLI tool this is nearly irrelevant, so I'm fine having Claude churn this stuff out.

3. Learning

On the learning front, one of my biggest highlights this year was how I managed to read 49(!) papers for SWE Tea. SWE Tea really has been a joy to do, and frankly it's quite high return. We read through a series a topics, from huge pages to LLM post training to data center power and so on, and we dived deep into many of the topics. I've learned a ton from SWE Tea, it's definitely been one of the best decisions I've made in recent history.

On a meta note, I'd say I've learned two things about running a paper reading group:

Reschedule, never skip. If you get into the habit of skipping weeks, you'll end up normalizing the deviation and then eventually drop off.
Batch themes together. When we first started SWE Tea, we did papers in roughly random topics, jumping around. However, batching papers chronologically allows you to trace the evolution of a technology. For example, in our latest theme of sanitizers, we started with Valgrind, walked through ASAN and TSAN, and worked our way up to memory tagging. This was something we happened upon this year, and it's really helped us read these papers. Not only do you maintain context between each week and the next, you can compare and contrast papers and authors in the same field.

Unfortunately, this year has been somewhat bad for my reading and language studying. I've kept up my Arabic and Spanish studying, but those have effectively been high fluency for a while, and only require maintenance mode. I started the year studying Russian but quickly had to give up due to a lack of time. I'd like to pick it back up next year.

I've only read 23 books this year, although some of the books were excellent. Highlights include:

Glorious Exploits, by Ferdia Lennon
- I didn't know what to expect going into this book, but it was an excellent emotional tug on the act of putting on a play. The theme sounds contrived, but it's short and I'd greatly recommend it
People from Oetimu, by Felix K. Nesi
- I discovered Archipelago Books relatively recently, and I was enchanted with this particular book. Nesi writes beautifully, and weaves a fascinating historical fiction of the Indonesian occupation of Timor.
Planet of Slums, by Mike Davis
- This book was on my to read list for a while, and I kept putting it off. When I finally sat down to read it, I was enchanted by the prose and arguments. If you're into books like Drug Cartels Do Not Exist or similar type of academic books, this one will draw you in as well.
Secular Translations: Nation-State, Modern Self, and Calculative Reason, by Talal Asad
- This was technically a re-read, but honestly I got so much more out of the re-read than the first read. One of the biggest benefits of re-reading authors like Asad is that you pick up so much more with time and distance. I read this originally for school in my MA program, picking it back up years later showed me so much more. Asad's description of language and how it gets used and reworded in this book is clearer than most of his other books, with banger quotes such as³:
  
  The translation of values from one natural language to another is always problematic, as every anthropologist who has carried out research in a society that speaks a language foreign to her own knows. Which is why what makes sense to a Western ethnographer in a nonmodern community sometimes doesn’t do so as easily when she returns home to Euro- America. It is almost impossible to abstract an important idea that indicates something distinctive of a particular form of life and find a ready word in a language belonging to a very different form of life…

4. Life

Looking back, this year has really been leaning into being a big tech worker. I've ramped up to 4 days of crossfit a week, with the plan of going up to 5 days a week in January next year. I've stayed around New York, feeling some aches to leave but not firm plans on permanently leaving yet. I didn't get a chance to do a big bike trip like my Montreal bike trip last year, but I've really thrown myself into crossfit as a result.

Crossfit has been my point of sanity. With a stressful job, having the ability to just hop over to a gym and lift heavy shit during the middle of the day has kept me grounded. Having good trainers that help drive me towards clear progressions in my goals is a good anchor in the waves at work.

One of the things that you learn quickly when working at big tech is the scale of impact and how many problems really are organizational problems. WhatsApp server is very few people, and yet the product is routinely used by billions of people across the world a day. I spend most of my time consensus building at work, drafting alignment docs and firefighting, and I expect that to only stay constant or grow with time. This is sort of the life of big tech, where people end up fighting over stuff like "scope" or "consensus."

I haven't yet decided how I feel about it. I like the opportunities big tech affords me, I enjoy working on large industrial scale software, and I love the fact that I can sightsee and that my coworkers on WhatsApp are incredibly smart. On the other hand, it is exhausting at a particular point, I somewhat miss my old job, where I was putting in significantly less hours.

Now that I've come back to NYC after a few years away, the last year and a half can be described as a lack of FOMO. When I first moved to NYC, I was desperate to go to all the events, see all the people, so on. Now I'm at the stage where I'd prefer quiet nights and make time to see specific friends, which I suppose means that I have come down with a case of the old.

I recently chatted with a friend about this, who pointed out that I had an interesting, well paid job, and have roughly everything else lined up in life. Which is all true, but I constantly feel the pang of wanting to head back into the chaos of the Middle East.

I've forgotten where this came from (perhaps 4X games), but a while back I heard about the expand/exploit tradeoff. With the limited resources of time, I've felt like the past few years I've been expanding, seeing the world, learning new things, and so on. This last year, I've felt like I've been in the exploit phase, focusing on myself and getting really good at software. Part of it has been accepting that I'm in exploit mode for now, banking skills and resources while the expand urge waits.

For now, I'm choosing depth over breadth. We'll see how long that lasts.

النعجة - اجعوط مصطفى

One of my favorite pieces in the Algiers calligraphy museum, titled "The Sheep" by Mustafa Ajaout.

Footnotes:

And I even broke WhatsApp a bit myself!

I'm old. uv is still "new" to me.

Asad, Talal. Secular Translations: Nation-State, Modern Self, and Calculative Reason. Columbia University Press, 2018. https://doi.org/10.7312/asad18968.

Dilettantes and Polymaths

Ghettos of Abu Nawas — Sun, 28 Dec 2025 02:00:00 GMT

Dilettantes and Polymaths

this post is far more rambling than my regular ones

It's been a year. Normally I'd write up something wrapping up about my goals and how far I accomplished, but I think for me this year was one long lesson in understanding the difference between being a dilettante and a polymath.

I've always been terrified of being a dilettante, mostly because it creates some sort of "crank" identity, such as the weirdos who post about timecubes or start "writing" (if we can use that term) stuff and putting it on vixra. Being a dilettante always seemed being like those DC bro types who start writing essays about "death the of Hong Kong", having never been there. Dilettantism slides easily into delusions, especially as the world concentrates more and more power into smaller and smaller segments of people. How can anyone trust their own decisions when the knowledge you have is so subjectively little? Pikety writes about how economists should stop adopting mathematical language when economists know very little of anything, the language and rigor are separate things. The same thing happens in nearly all the social sciences at this point, the poor undergrad kid aggressively trying to p-hack his way to a paper is subject to the greater forces of adopting language without rigor.

What the hell is a polymath then? To be honest, I used to think it was someone that picked specific fields and went deep into them. For me, the stuff I wanted to master was distributed systems, militias in Iraq, and linguistic shit. Which, all things considered, is going pretty well. I switched teams at work to the NLP team, which rekindled my desire for software engineering while opening doors to working on more linguistics-related things, but also am going deep into Kubernetes currently. So that's been working out pretty well.

Back to polymath-ism. There's actually a novel called "The Polymath" that's about Ibn Khaldun, which I've been meaning to read about this. Ibn Khaldun was brilliant, and I can really only hope to reach a portion of the amount of insight he produced. Yet one thing I'm beginning to notice is that knowledge production and bridging is what has differentiated my current work from the past. I'm actively writing more and attempting to bridge my knowledge of software, middle east studies, and linguistics, on higher levels than I had thought before. I'm rereading Godel, Escher, Bach again, while reading Steps to an Ecology of Mind for the first time. At the same time, I'm going through a book club on Braben's Scientific Freedom.

So it's been a year. I bought a place, I trained a lot more, I studied a lot more, and at the end of it, the only lesson I have is that I need to rethink how I approach ideas. I used to think ideas were static sets of things to acquire or discard, each idea was a historical nugget to either stash away, use quickly, or chuck out. But at the end of this year, I've realized that I need to let the ideas ruminate and grow in the background, the ecology of the mind, as it were. Who knows what next year is going to be like, but I weirdly have a feeling it's going to be a good year.

Fieldnotes

Ghettos of Abu Nawas — Sun, 28 Dec 2025 02:00:00 GMT

Fieldnotes

1. Central America
2. South America
3. Middle East and North Africa

Midnight volleyball in Fort Washington Park, 2021.

Some fieldnotes from various places I've lived in. I usually will write up a section for any country I've lived for more than a month in.

1. Central America

El Salvador

2. South America

3. Middle East and North Africa

Pret's Fruit Cup

Ghettos of Abu Nawas — Sun, 28 Dec 2025 02:00:00 GMT

Pret's Fruit Cup

I prod the strawberry with my fork. It's actually half of a strawberry, sliced in twain by some machine at some indeterminate time ago. The plastic cup it came in promised "organic" and "fresh daily", although I figure companies like Pret probably have redefined "daily" in terms of elephant years or something. The bottom tip of the strawberry's red flesh is a bit mushy, but also sweeter than the rest of it. I pause, briefly considering if this strawberry's other half is in another fruit cup somewhere. Did I partake in deporting a strawberry from it's better half? Cause this half was very mediocre.

There's blueberries too. And some grapes, although grapes are the definition of filler in fruit cups. No one's asking for a grape cup, cause that just makes you seem weird, like some bizarre alcoholic who needs alcohol before it's fermented. The grapes are fine, just like the strawberry half. This is like my AP Language essays that came back with C+ on the top criticizing me for my lack of proper structure, or my lack of diction, or, the worst of them all, my lack of theme. What the hell, if you read through my entire essay about some crisis and you couldn't figure out the theme it's not my fault, perhaps you're just too dumb.

Back to the fruit cup. The blueberries are astoundingly fresh, like they've just been picked. Maybe Pret does use human time for it's "daily". One has to gaze in awe at the sheer variation of quality within a single fruit cup, like a world unto itself.

In the end, it all disappears into my gullet anyways. It was a goddamn eight dollar fruit cup, because New York brain damage everything is hideously overpriced. Whatever, I'll be back in a month once the shame of the eight dollar fruit cup subsides.

Read the Damn Error Message

Ghettos of Abu Nawas — Sun, 28 Dec 2025 02:00:00 GMT

Read the Damn Error Message

1. Example
2. Debugging Mentality

I've been working on a project for grad school, and through watching my teammates, I've seen them exhibit some of the same behaviors I see juniors do. The most frustrating one is the inability to debug, or the failure to reason about debugging.

For example, given this traceback:

Traceback (most recent call last):
  File "/scratch/username/nlu/experiment-script.py", line 354, in <module>
    tot = loader(dataset_name, tokenizer, args.cache_dir)
  File "/scratch/username/nlu/experiment-script.py", line 150, in loader
    tot.append(_preprocess_dataset(dataset_name, data, sentence_col, tokenizer))
  File "/scratch/username/nlu/experiment-script.py", line 157, in _preprocess_dataset
    data = data.map(
  File "/scratch/username/envName/lib/python3.9/site-packages/datasets/dataset_dict.py", line 432, in map
    {
  File "/scratch/username/envName/lib/python3.9/site-packages/datasets/dataset_dict.py", line 433, in <dictcomp>
    k: dataset.map(
  File "/scratch/username/envName/lib/python3.9/site-packages/datasets/arrow_dataset.py", line 1407, in map
    update_data = does_function_return_dict(test_inputs, test_indices)
  File "/scratch/username/envName/lib/python3.9/site-packages/datasets/arrow_dataset.py", line 1378, in does_function_return_dict
    function(*fn_args, indices, **fn_kwargs) if with_indices else function(*fn_args, **fn_kwargs)
  File "/scratch/username/nlu/experiment-script.py", line 158, in <lambda>
    lambda x: tokenizer(x["input_text"], padding="max_length", truncation=True),
  File "/scratch/username/envName/lib/python3.9/site-packages/transformers/tokenization_utils_base.py", line 2210, in __call__
    assert isinstance(text, str) or (
AssertionError: text input must of type `str` (single example), `List[str]` (batch or single pretokenized example) or `List[List[str]]` (batch of pretokenized examples).

I've seen junior engs completely ignore this traceback, thinking it's all garbage. Alternatively, I've also heard the excuse that Python isn't their wheelhouse, so it's fine to not know how to read this, or that their area of focus is experimentation and not writing/reading/debugging code.

Both of these concepts are absurd. Junior engs miss a treasure trove of information when they skip the traceback. Programmers, whether as grad students or software engineers, will read a magnitude more code than they write. Learning how to debug code that you don't understand is simply an extension of that. CS grad students are never explicitly taught how to read a paper, yet it's expected for students to simply "pick it up" along the way. Reading and reasoning about unfamiliar code is an invaluable skill, one that allows programmers to work in a variety of environments. In hopes of fixing that, I'm going to walk through how I would debug this particular traceback, and then talk about the mentality programmers should approach debugging with.

1. Example

Going back to the traceback above, I'll walk through my chain of reasoning and how to debug it. There's already many tutorials on how a traceback is structured, but I'm going to walk through this specific one with an example.

1.1. Tracebacks is a structured logs

Because tracebacks are structured logs, they should be read from the point of error, and work backwards to isolate the specific problem. In this case, the error is helpfully at the bottom, so I'm going start by reading from the bottom up.

1.2. Read the actual error

AssertionError: text input must of type `str` (single example), `List[str]` (batch or single pretokenized example) or `List[List[str]]` (batch of pretokenized examples).

This error is fairly explicit, it's telling us that the text input must be of a specific type. If this is unclear, the line above helpfully gives an example, stating assert isinstance(text, str) or (. So now we know that there's a type mismatch somewhere.

1.3. Check the filenames, switch the reading order

Now, knowing what the error is, we need to find out where the error comes from. Now it could come from anywhere within the traceback, and there's a lot of information, so we need to narrow it down quickly. One of the first passes I usually do is scanning the filenames¹.

In this traceback, we know that error line that comes from /python3.9/site-packages/datasets/ is coming from the datasets library, so we can likely discard it. Mentally, after removing all the error lines that comes out of the datasets library, we have:

Traceback (most recent call last):
  File "/scratch/username/nlu/experiment-script.py", line 354, in <module>
    tot = loader(dataset_name, tokenizer, args.cache_dir)
  File "/scratch/username/nlu/experiment-script.py", line 150, in loader
    tot.append(_preprocess_dataset(dataset_name, data, sentence_col, tokenizer))

<<datasets library stuff....>

  File "/scratch/username/nlu/experiment-script.py", line 157, in _preprocess_dataset
    data = data.map(
  File "/scratch/username/nlu/experiment-script.py", line 158, in <lambda>
    lambda x: tokenizer(x["input_text"], padding="max_length", truncation=True),

This is far more readable, and can be read top-down! Going back to the idea that tracebacks are structured logs, structured logs should be read bottom-up to identify what and where the problem is, but then logs should be read top-down to how the error occurred. Reading logs top-down gives the ability to reconstruct the flow of the program itself.

In this case, we can see that the the loader function is called, which then calls append, which then calls into the datasets library, and then eventually calls into a map on a lambda. So now we know that there's something wrong with the lambda function.

1.4. Print it (or use pdb)

At this point, it becomes unclear what's going on. It seems like the problem is x["input_text"] has a mismatching type, but we can't really be sure until we have a little more debugging information. The next stage can be done by simply replacing the tokenizer call with a print call, so lambda x: tokenizer(x["input_text"], padding="max_length", truncation=True becomes lambda x: print(x["input_text"], type(x["input_text"])).

At this point, the answer was that x["input_text"] returned an incorrect datatype.

2. Debugging Mentality

The above traceback is a good example of working through the debugging mentality. The error messages will most likely tell you what the errors are, and the role of a programmer during debugging is to find out the where and the how. As a result, it's important to not approach debugging with a specific hypothesis. Each stage in the debugging process should give you more questions, and a programmer must use their brain in debugging. The goal of debugging is not to come in with a specific hypothesis and attempt to prove/disprove it, but rather to find the correct set of questions to answer, and gradually narrow it down. It's important to remain intellectually curious about how your system can behave pathologically.

If a programmer comes into the system with a predetermined set of hypotheses, it's easy to fiddle around with the code in order to (dis)prove those hypotheses. This is a very "scientific method" point of view, but as programmers, we luckily don't have to be constrained by that! The scientific process operates on information, which is why the mode and technique of inquiry is important. But software is both information and a process², which means that programmers do not have to be bound in the same way. We can observe software in action, and take the logs of software to reconstruct the events, rather than testing specific conditions. As a result, it's important to never let your hypothesis about bugs overshadow what the error messages are saying.

Footnotes:

Yes, I know the error is coming from directly the line above it, but I'm going to pretend to not understand the lambda for example purposes.

Bryan Cantrill said this in some talk I can't recall.

Shrines

Ghettos of Abu Nawas — Sun, 28 Dec 2025 02:00:00 GMT

Shrines

1. Locations:

1. Locations:

Photographs of various shrines I've seen. A shrine here is basically anything I consider to have spiritual significance.

< 2021:07:21 09:55:40 > - < 36.7586833333333, 43.8936416666667 >

< 2021:07:21 11:25:05 > - < 36.7682833333333, 43.8941166666667 >

< 2025:05:04 09:07:04 > - < 36.7849083333333, 3.06117222222222 >

< 2019:07:05 16:42:06 > - < 31.9500888888889, 35.9348805555556 >

< 2021:08:21 11:26:04 > - < 30.5183805555556, 47.8370138888889 >

< 2021:08:21 16:46:12 > - < 30.4000805555556, 47.7329 >

< 2022:04:05 14:46:38 > - < 52.5051333333333, 13.3355305555556 >

< 2017:11:19 11:49:19 > - < 42.8782055555556, 74.6085277777778 >

< 2023:11:19 16:46:06 > - < -34.5871666666667, -58.4275361111111 >

< 2023:11:19 19:27:05 > - < -34.6173666666667, -58.3731277777778 >

< 2023:05:06 11:17:21 > - < 36.9710305555556, 43.3164527777778 >

< 2021:12:30 21:41:04 > - < 40.7478916666667, -73.9400722222222 >

< 2021:07:10 13:30:36 > - < 36.2012555555556, 44.0189222222222 >

< 2022:11:02 13:34:22 > - < 39.4537305555556, -31.2631083333333 >

< 2017:12:13 15:24:18 > - < 35.2342944444444, 139.095322222222 >

< 2022:07:14 22:57:18 > - < 32.6178972222222, 44.0359388888889 >

< 2022:03:27 16:00:34 > - < 32.6511333333333, 43.984925 >

< 2021:08:17 16:38:29 > - < 32.2266416666667, 44.367325 >

< 2023:04:28 12:21:13 > - < 32.6158361111111, 44.032425 >

< 2022:03:27 16:25:08 > - < 32.5944027777778, 44.0308694444444 >

< 2022:09:13 22:22:00 > - < 32.3225666666667, 44.2666444444444 >

< 2022:09:13 12:33:52 > - < 32.17915, 44.3124555555556 >

< 2021:07:21 14:01:17 > - < 36.771225, 43.3034694444444 >

< 2022:11:11 14:20:35 > - < 38.697475, -9.20533888888889 >

< 2023:06:11 15:11:31 > - < -34.9033777777778, -56.2006861111111 >

< 2023:04:28 17:00:31 > - < 31.996075, 44.3149527777778 >

< 2021:08:20 10:10:30 > - < 30.9798, 47.0426555555556 >

< 2022:04:07 15:15:53 > - < 48.8777916666667, 2.30157222222222 >

< 2022:10:26 17:04:06 > - < 37.7402583333333, -25.6622444444444 >

< 2023:02:11 13:44:19 > - < 33.4045944444444, 43.4746388888889 >

< 2021:07:21 15:02:46 > - < 36.7489916666667, 43.1152416666667 >

< 2025:08:16 11:28:31 > - < 13.6972888888889, -89.1890472222222 >

< 2023:03:11 17:00:44 > - < 37.7554944444444, -122.41735 >

< 2023:03:12 15:53:12 > - < 37.4145777777778, -122.077561111111 >

< 2023:05:15 16:51:08 > - < 35.668, 45.0039027777778 >

< 2023:05:14 01:23:35 > - < 35.5663027777778, 45.3740194444444 >

< 2023:11:05 13:46:30 > - < -54.8397555555556, -68.3120194444444 >

< 2024:01:13 17:32:06 > - < -34.8535166666667, -55.9860916666667 >

El Salvador

Ghettos of Abu Nawas — Sun, 28 Dec 2025 02:00:00 GMT

El Salvador

1. Fiestas de Agosto
- 1.1. Mass on the 6th
2. Romero
3. Misc
4. Wrap

I just came back from three weeks in El Salvador. You land to a giant sign that says "El Salvador, the Land of Smiles," which might be a stretch. Summer means rain most afternoons; thunderstorms drift through most evenings for an hour or two.

I spent three weeks in the city for the Fiestas de Agosto and San Salvador's 500th anniversary of its founding. I came for the procession and stayed for small things: pupusas on paper, Cadejo blond ale cold, guards choreographing gates. It felt safe in the center and easy to move. The coast and a volcano sit a short drive away. These notes are about the capital, plus a hike and a beach run.

San Salvador is not really a walkable city beyond the center, which closes early. Barbed wire separates most neighborhoods, and most people get around by motorcycle or car. Like parts of the Middle East, wealthier areas self-segregate into small malls and shopping zones, while walkability is less prized. There are token bike lanes in some wealthy areas, but it's not easy to walk around.

Military presence is everywhere. Although none of them checked my ID¹, soldiers are posted across the city.

1. Fiestas de Agosto

Sivarland at night. Rain slick, smoke, Ferris wheel lit.

I came into the festival by the southern gate around 8pm. First hit was sugar and oil from churros, then gunpowder. Generators droned. Cables sagged over the walkway. A kid, fingers sticky, bumped into me and the parent shot me an apologetic look.

Soldiers are present without hurry. Long guns slung, hands light on the grip. At the gate, they asked three questions, looked at my bag, and waved me through. The choreography at gatehouses is quick: a nod, a clipboard, a latch.

Sivarland, the carnival zone, runs loud for six days at the start of August². Ferris wheels, drums, fireworks, vendors in the street. The point is to celebrate the Transfiguration of Christ, with the fiesta leading up to the event mass at the metropolitan church.

“Elotes Locos,” “Papitas Fritas,” “Churros Españoles.” Prices in marker, cables overhead.

I walked the loop twice looking for a beer and failed. Drinks were soda and water; I gave up and had a cold one at home. Maybe that’s policy during the fair. There was a concert going on as well, and carnival rides and families gathered everywhere. Circus animals, and plenty of military strolling around.

It’s a carnival threaded with Jesus: banners on ride fronts, a small altar by the speakers, a prayer before the fireworks.

1.1. Mass on the 6th

Gathered at mass.

The Catedral Metropolitana filled for the Transfiguration. I stood for hours in sun and shade. The homily circled Romero and opened with a prayer for migrants in the United States. People shaded their faces with programs and parasols. Water sellers threaded the aisle. A woman beside me whispered each response half a beat early. When the final hymn started the square sang back.

The mass was reserved. The priest focused on Salvadorans in the US in light of recent deportations, then transitioned to Romero and the struggles of priests past. I've been to many masses in Mar Yousef in Erbil, and this one felt tame in comparison.

The cathedral square is big, with one of those small parks that has a few water fountains from the ground for children to play in. There's a variety of good coffee shops around³ the square itself, framed by the gigantic National Library⁴ and the National Palace. It's a relaxing area. Later in the day, I trekked back inside the cathedral, and it's surprisingly sparse. The cathedral still has two large portraits of Romero hanging on the side:

Romero is present in the air, not just in museums. The priest quoted him twice; the crowd answered both times. This was particularly surprising to me, as I had vaguely known about his influence, but never seriously considered it. Matt Eisenbrandt puts it⁵:

Óscar Romero is one of the towering heroes in El Salvador’s history whose influence transcends the borders of that small country. Romero’s impact can be measured quantitatively, by the 100,000 mourners who risked their lives to attend his funeral, or by the disturbing truth that his assassination accelerated El Salvador’s descent into civil war.

2. Romero

He is everywhere: bus decals, murals, keychains at the cathedral gate. The strongest encounter was at the hospital chapel where he was killed. A small room holds his vestments and diary pages. The guide speaks softly and points with two fingers. Outside, a white rose bush is kept trimmed. The shadow he casts is practical as much as holy: quotes on banners, names on parish flyers, a tone of moral certainty in casual talk.

I found the Museo de la Palabra y la Imagen to be the default memory/genocide museum. While small compared to the Art Museum or the Dr. David J. Guzmán National Museum, it had a dedicated exhibition on Romero and the civil war.

The Romero section was filled with photos of his life, including the elephant he met at the San Salvador Zoo. Photos of him preaching, busts of his face, his family, his notes. The whole space functioned as a shrine, and that's striking because many religious figures people strive to emulate are far away (temporally speaking). Kobo Daishi, Anastasia, and Hussein exist as canonical figures, but Romero exists in color photographs. You can walk the same paths he did, go to the same restaurants he did. Many people who are still alive today remember him.

There's an art to the construction of a saint, especially one that transgresses borders. Romero functions as a politicized sainthood, and I'd almost place him alongside Sheikh Abdesslam Yassine, the Moroccan cleric who wrote Al-Islam aw al-tufan⁶ to admonish King Hassan II. This form of sainthood is active: Yassine set himself against an oppressive regime, and both he and Romero cast long shadows with religious authority contrasted against political power.

Saints are made by the people before they are made by institutions, which you can see in Romero's late canonization in 2018. But Salvadoran society is saturated with Romero, which raises the question of how a living saint becomes a martyr when reproductions and evidence of their life are so obvious and near. Martyrdom is almost easier without photos and documents; you can dramatize, reproduce, replay the saintly life into thematic principles. But Romero and Yassine are difficult to shape or dramatize, as their lives press so close to believers.

Self-censorship is a spectrum, but I had expected there to be significantly less space dedicated to the civil war than there actually was. Numerous photos, faces in black-and-white prints of fighters, and an old classroom kept as it was. A small candle monument to those who died, and an entire gigantic room dedicated to a reproduction of Radio Venceremos.

Reproduction of the broadcasting room.

Radio Venceremos was one of the largest anti-government radio stations of the FMLN. Famously, the government tried so hard to shut them down that radio broadcasters used themselves as bait to lure a government general, and shot down his helicopter. It was on Venceremos that the end of the civil war was broadcast. This room is remarkable as well in its completeness, one can easily see that this room was carved with care.

3. Misc

I was vaguely aware that Bukele was Palestinian, but I didn't realize how much emigration of Palestinians occurred to El Salvador until I walked by Schafik Hándal's massive grave.

Handal was the general secretary of the FMLN, and fought against the government and then eventually transitioned to becoming a politician.

It's in the food too; I kept seeing quibe (kibbeh) on menus and even a restaurant called "Matkub." The graves of Palestinian resistance fighters are all over the necropolis too.

4. Wrap

I liked El Salvador. It's a small country, so you can cross it in a few hours, but there's surprising depth in the politics and history. I especially enjoyed the necropolis; it resembles the one in Buenos Aires.

More Photos: Link

Footnotes:

In Lebanon and Iraq, I'd expect checkpoints staffed by the military to stop me and check IDs. I hit zero checkpoints in El Salvador.

“Sivar” is a local nickname for San Salvador.

Salvadorans are proud of their coffee production and culture.

⁴

Donated in part from the Chinese apparently.

⁵

Eisenbrandt, Matt. Assassination of a Saint: The Plot to Murder Óscar Romero and the Quest to Bring His Killers to Justice. University of California Press, 2017.

⁶

"Islam or the Deluge"

Building Hacker News Games

MARCO LABARILE — Sun, 28 Dec 2025 01:00:00 GMT

How I built a videogames catalog from HN submissions and the idea behind it.

25 from '25

Something About Cats — Sat, 27 Dec 2025 23:37:48 GMT

The best yet?

Moodboard

Brian Sunter — Sat, 27 Dec 2025 16:05:46 GMT

An infinite-canvas moodboard with sticky notes and images. Pan, zoom, drop things wherever they make sense.

<generate-html> Web Component

Modern Web Development with Chrome — Sat, 27 Dec 2025 14:00:00 GMT

I've created the <generate-html> Web Component, an LLM-powered tool that generates and renders interactive HTML or SVG images securely using Google Gemini or Chrome's built-in AI. It features a "Double Iframe" architecture for security, supports multiple providers, and has zero framework dependencies. It also allows for template context to guide LLM output.

Deep Research Email

Modern Web Development with Chrome — Sat, 27 Dec 2025 14:00:00 GMT

I've been exploring how to integrate advanced AI agents into my daily workflow, and email remains the most universal interface for asynchronous tasks. I built a "Deep Research" agent using Val Town that allows me to trigger complex research tasks simply by sending an email. It uses Google's Deep Research model to perform the heavy lifting. It is pretty simple to get started, you just need to send an email.

The Tech Industry After the Gold Rush

Kevin Coleman — Sat, 27 Dec 2025 07:49:55 GMT

Over the last year, I’ve found myself increasingly jaded about the tech industry.

1Password Dependency Breaks Syntax Highlighting

Fernando Borretti — Sat, 27 Dec 2025 03:00:00 GMT

Why does a password manager need a syntax highlighter?

AWS Cost Optimization Case Study: How I Cut a Client's Bill by 50%

Sat, 27 Dec 2025 02:00:00 GMT

Last month, a client’s AWS bill hit $5,000 — up 40% from last year with no clear explanation.

After one week of systematic analysis, I cut it to $2,500/month — a 50% reduction, saving them $30,000 annually. Here’s exactly how I did it, with the scripts you can use.

The Discovery Phase: How I Found the Problems

Before touching anything, I needed to understand the infrastructure. Here’s my systematic approach:

Step 1: Pull Cost Data by Service

First, I analyzed their AWS Cost Explorer data to understand where money was going:

aws ce get-cost-and-usage \
  --time-period Start=2024-11-01,End=2024-11-30 \
  --granularity MONTHLY \
  --metrics "BlendedCost" \
  --group-by Type=DIMENSION,Key=SERVICE

This gave me the high-level breakdown. But I needed more detail.

Step 2: Build a Resource Inventory

I wrote a Python script to scan all resources across regions and identify optimization opportunities:

import boto3

def scan_ebs_volumes():
    """Find GP2 volumes that should be GP3 and unattached volumes."""
    ec2 = boto3.client('ec2')
    volumes = ec2.describe_volumes()['Volumes']

    gp2_volumes = []
    unattached = []

    for vol in volumes:
        if vol['VolumeType'] == 'gp2':
            gp2_volumes.append({
                'VolumeId': vol['VolumeId'],
                'Size': vol['Size'],
                'State': vol['State'],
                'MonthlyCost': vol['Size'] * 0.10,  # GP2 pricing
                'GP3Cost': vol['Size'] * 0.08,      # GP3 pricing
                'Savings': vol['Size'] * 0.02
            })

        if vol['State'] == 'available':  # Not attached
            unattached.append(vol)

    return gp2_volumes, unattached

I built similar functions for:

RDS instances (storage type, utilization, Multi-AZ necessity)
EC2 instances (generation, Reserved Instance coverage)
Elastic IPs (attached vs idle)
EBS snapshots (age, associated volumes)
S3 buckets (storage class, lifecycle policies)

Step 3: Analyze CloudWatch Metrics for Utilization

This is critical. Before recommending any right-sizing, I needed data:

def get_instance_utilization(instance_id, days=30):
    """Get average CPU utilization over the past N days."""
    cloudwatch = boto3.client('cloudwatch')

    response = cloudwatch.get_metric_statistics(
        Namespace='AWS/EC2',
        MetricName='CPUUtilization',
        Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
        StartTime=datetime.now() - timedelta(days=days),
        EndTime=datetime.now(),
        Period=86400,  # Daily
        Statistics=['Average', 'Maximum']
    )

    return response['Datapoints']

The results were eye-opening:

Two t3.xlarge instances averaging 12% CPU
RDS storage at 95% free space
Multiple log groups with no retention policy (storing terabytes)

Step 4: Map Dependencies Before Cutting

Before deleting anything, I mapped what depended on what:

Which services used which Elastic IPs?
Which applications wrote to which log groups?
Which backups were actually needed for compliance?

This prevented the classic mistake of breaking production while optimizing costs.

The Starting Point

After the discovery phase, here’s what I was working with:

Service	Monthly Cost	% of Total
EC2-Other (EBS, NAT, IPs)	$1,250	25%
RDS	$750	15%
EC2 Compute	$650	13%
CloudWatch	$500	10%
AWS Backup	$500	10%
ECS Fargate	$400	8%
S3	$250	5%
VPC	$250	5%
Everything else	$450	9%
Total	$5,000	100%

The distribution told me a lot. EC2-related costs (compute + EBS + networking) made up over 38% of the bill. That’s where I started.

Phase 1: Quick Wins (Implemented Same Day)

Release Idle Elastic IPs — Saved $50/month

My inventory script flagged 5 Elastic IPs with no association:

aws ec2 describe-addresses --query 'Addresses[?AssociationId==null]'

Someone had provisioned them for test environments that were deleted months ago. Classic ghost infrastructure.

Time to fix: 5 minutes.

Migrate EBS GP2 to GP3 — Saved $125/month

The script found 6,000+ GB across multiple EBS volumes still on GP2. GP3 costs 20% less and provides better baseline performance (3,000 IOPS vs GP2’s variable IOPS based on size).

aws ec2 modify-volume --volume-id vol-xxx --volume-type gp3

No downtime. Just a CLI command per volume.

Time to fix: 30 minutes for all volumes.

Set CloudWatch Log Retention — Saved $100/month

My scan found 20+ log groups with no retention policy — storing logs forever:

aws logs describe-log-groups --query 'logGroups[?retentionInDays==null].logGroupName'

Set production to 90 days, staging to 30 days.

Time to fix: 20 minutes.

Phase 2: The Big Discoveries

AWS Backup Running 24x More Often Than Needed — Saved $400/month

This was the most surprising find. When I pulled the backup plan configuration:

aws backup get-backup-plan --backup-plan-id xxx

I saw: hourly backups. 24 backups per day. For every resource.

The backup storage had grown to $500/month — 10% of their total bill.

I reviewed their recovery requirements (they only needed daily backups with 14-day retention) and reconfigured:

{
  "ScheduleExpression": "cron(0 5 * * ? *)",
  "StartWindowMinutes": 60,
  "CompletionWindowMinutes": 120,
  "Lifecycle": {
    "DeleteAfterDays": 14
  }
}

Time to fix: 1 hour (including testing).

CloudWatch Metric Streams to Nowhere — Saved $400/month

My CloudWatch cost breakdown showed $400/month on “Metric Streams” — 100+ million metric updates going somewhere.

aws cloudwatch list-metric-streams

Found a stream configured to send data to a third-party monitoring tool. When I asked about it, nobody on the team knew it existed. The integration had been set up by a previous contractor and was never used.

This is a perfect example of ghost infrastructure that accumulates over time.

RDS Over-Provisioned by 95%

My RDS analysis showed all instances had massive storage allocated. The CloudWatch metrics told the real story:

aws cloudwatch get-metric-statistics \
  --namespace AWS/RDS \
  --metric-name FreeStorageSpace \
  --dimensions Name=DBInstanceIdentifier,Value=production-db \
  --start-time 2024-11-01T00:00:00Z \
  --end-time 2024-11-30T23:59:59Z \
  --period 86400 \
  --statistics Average

Result: 95% free space across all databases.

RDS storage can only be increased, not decreased. But I migrated all instances from GP2 to GP3 storage — same price, better performance.

For the next database refresh, I recommended right-sized storage instead of the default massive allocations.

Saved: $150/month

Phase 3: Infrastructure Improvements

NAT Gateway Consolidation — Saved $125/month

My VPC analysis showed NAT Gateways in every AZ across multiple regions costing $500/month combined. After reviewing their architecture and traffic patterns, they only needed half of them.

ECS Task Right-Sizing — Saved $250/month

The ECS service scan found:

A staging service constantly failing health checks and restarting (consuming resources 24/7 while accomplishing nothing)
Legacy services still running in production that nobody was using

These issues relate directly to the ECS architectural decisions that often waste weeks of engineering time. Plus, enabled Fargate Spot for fault-tolerant workloads (70% savings on those tasks).

S3 Lifecycle Policies — Saved $150/month

My S3 bucket analysis showed backup buckets had grown to 10+ TB with no lifecycle policy. Old backups were stored in Standard tier forever.

Added a policy to transition to Glacier after 90 days:

{
  "Rules": [
    {
      "ID": "archive-old-backups",
      "Status": "Enabled",
      "Transitions": [
        {
          "Days": 90,
          "StorageClass": "GLACIER"
        }
      ]
    }
  ]
}

Reserved Instances for Stable Workloads — Saved $500/month

My EC2 coverage analysis showed zero Reserved Instance coverage on instances running 24/7.

I helped them purchase Compute Savings Plans covering their steady-state workloads. Immediate 30-40% savings on compute.

EC2 Instance Right-Sizing — Saved $250/month

The utilization data was clear: multiple instances running at 10-15% CPU.

Downsized t3.xlarge instances to t3.large where utilization data supported it. Same workload, half the cost.

The Results

Category	Monthly Savings
Reserved Instances / Savings Plans	$500
AWS Backup (hourly → daily)	$400
CloudWatch Metric Streams	$400
ECS cleanup + Fargate Spot	$250
EC2 right-sizing	$250
S3 lifecycle policies	$150
RDS improvements	$150
EBS GP2 → GP3	$125
NAT Gateway consolidation	$125
CloudWatch log retention	$100
Idle Elastic IPs	$50
Total Monthly Savings	$2,500

From $5,000/month to $2,500/month — exactly 50% reduction.

Over a year, that’s $30,000 back in their pocket.

The Methodology

Here’s the systematic approach I use for every cost optimization engagement:

1. Get the Data First

Before making any changes, I pull:

AWS Cost Explorer data (by service, by tag, over time)
CloudWatch metrics for utilization
Resource inventory across all regions

2. Find the Ghosts

“Ghost infrastructure” costs more than you think:

Unused Elastic IPs
Detached EBS volumes
Empty S3 buckets accumulating requests
Log groups with infinite retention
Metric Streams nobody monitors
Test environments that outlived their purpose

3. Right-Size Ruthlessly

Check actual utilization before committing to Reserved Instances:

# EC2 CPU utilization over 30 days
aws cloudwatch get-metric-statistics \
  --namespace AWS/EC2 \
  --metric-name CPUUtilization \
  --dimensions Name=InstanceId,Value=i-xxx \
  --start-time $(date -d "30 days ago" +%Y-%m-%dT%H:%M:%S) \
  --end-time $(date +%Y-%m-%dT%H:%M:%S) \
  --period 3600 \
  --statistics Average

If a t3.xlarge averages 15% CPU, you’re paying for 85% idle capacity.

4. Modernize Storage

GP2 → GP3 is almost always worth it:

20% cheaper at baseline
Better performance (3,000 IOPS baseline)
Zero downtime migration

5. Review Backup Policies

Backups grow silently. Questions to ask:

How often do you actually need backups?
How long do you really need to keep them?
Are you backing up dev/test environments at production frequency?

What This Looks Like Over Time

Metric	Before	After
Monthly spend	$5,000	$2,500
Annual spend	$60,000	$30,000
Annual savings	—	$30,000

The best part? None of these changes affected performance or reliability. Most improved it.

Common Patterns I See

After doing this for multiple clients, patterns emerge:

Metric Streams nobody monitors — $100-400/month just disappearing
Hourly backups for daily restore needs — 24x the storage cost
GP2 volumes from years ago — never migrated to GP3
Multi-AZ staging databases — paying for HA nobody needs
NAT Gateways in every AZ — when one or two would suffice
Logs kept forever — “just in case”
No Reserved Instances — paying full on-demand for 24/7 workloads
Over-provisioned everything — “it might need it someday”

Need Help With Your AWS Bill?

I do AWS cost optimization as part of my DevOps consulting practice. If your AWS bill feels too high or you just want a second pair of eyes on your infrastructure, let’s talk.

Book a free 30-minute call — I’ll review your current setup and tell you where I see opportunities.

Have questions about any of these optimizations? Drop a comment below or reach out on Twitter/X.

On LLMs in programming

code · words · emotions: Daniel Janus’s blog — Sat, 27 Dec 2025 02:00:00 GMT

’Tis the year’s midnight, and it is the day’s.

Well, it’s two weeks past Lucy’s as I write this, but it is still that time of the year: the time of slowing down, taking a step back from the hustle and bustle of everyday, reflecting on what has happened and what is yet to come. Perhaps no better time to put together my thoughts on LLMs, and more specifically on their use in programming.

This post is not meant to take a stance in the ongoing discussion about the merits and risks of using LLMs. A lot has been said already about things like their moral and legal aspects, their energy footprint, how they impact society at large — I will skip all of this stuff, as I don’t have anything of value to add here. I do have opinions, but I don’t want to convince anyone. Rather, I hope to find some words to express and let out the anxiety that has been brewing in me for the last couple of months.

Where I stand

I might call myself a “conscious LLM-skeptic”. That is, while my attitude towards LLMs is far from enthusiastic, I do use them and have found them genuinely useful on multiple occasions in day-to-day programming. I used to have a Claude Pro subscription (I’ve cancelled it for the moment but it’s not unlikely I’ll renew at some point). I have no doubt that they’re here to stay, they’ve significantly changed the landscape of software development and will continue to do so.

So why the anxiety, instead of, say, enthusiasm?

I guess a large part of it is due to the change itself. Especially given the pace of it. A lot of things that I have grown accustomed to are now different than what they used to be; things that I had taken for granted no longer are. Change naturally breeds anxiety.

But I think there’s more to it.

Conscious excitement

Let me quote first a passage from “A Study in Scarlet”, where Dr. Watson discovers the extent of Sherlock Holmes’ knowledge of the world:

His ignorance was as remarkable as his knowledge. Of contemporary literature, philosophy and politics he appeared to know next to nothing. Upon my quoting Thomas Carlyle, he inquired in the naivest way who he might be and what he had done. My surprise reached a climax, however, when I found incidentally that he was ignorant of the Copernican Theory and of the composition of the Solar System. That any civilized human being in this nineteenth century should not be aware that the earth travelled round the sun appeared to be to me such an extraordinary fact that I could hardly realize it.

“You appear to be astonished,” he said, smiling at my expression of surprise. “Now that I do know it I shall do my best to forget it.”

“To forget it!”

“You see,” he explained, “I consider that a man’s brain originally is like a little empty attic, and you have to stock it with such furniture as you choose. A fool takes in all the lumber of every sort that he comes across, so that the knowledge which might be useful to him gets crowded out, or at best is jumbled up with a lot of other things so that he has a difficulty in laying his hands upon it. Now the skilful workman is very careful indeed as to what he takes into his brain-attic. He will have nothing but the tools which may help him in doing his work, but of these he has a large assortment, and all in the most perfect order. It is a mistake to think that that little room has elastic walls and can distend to any extent. Depend upon it there comes a time when for every addition of knowledge you forget something that you knew before. It is of the highest importance, therefore, not to have useless facts elbowing out the useful ones.”

I remember my astonishment at this thought process when I first read this. I might have been 11 or so at the time. Surely, I thought, the mind isn’t quite as rigid as Holmes paints it here? Surely you can keep throwing new information at it – the more, the better – and it will adapt, processing it, improving the mental model and discarding unuseful things?

But the older I get, the more I keep coming back to this attic analogy. Especially since I’ve learned about my ADHD a few years ago. I now believe that Holmes has a point here: that one needs to be careful and conscious when deciding what to furnish their brain with. Not necessarily with respect to facts, as per Holmes, but certainly with attention.

Because it’s attention that’s the scarcest, most precious resource that my brain has to offer. Even more precious than time (which, too, is scarce). Corollary: I need to choose very consciously what I devote my attention to.

Another thing I discovered is that attention and excitement are very much intertwined. Excitement arises when thinking about something deeply, and it is possible, to a certain extent, to induce excitement. It’s conscious, too. Corollary #2: I need to choose very consciously what to be excited about. It’s just basic fuckonomics.

And I’ve made a choice for those areas not to include LLMs – lest they divert my attention from things I care about.

I care about the fundamentals of my craft. I care about programming languages and their theory. I care about the trade-offs of static vs dynamic typing; of manual vs automatic memory management. I care about algorithms and data structures. I care about clarity when expressing ideas with code. I care about abstractions.

Most importantly, I care about the fun I’ve had from learning, exploring, and applying all these things. I choose to continue to derive the fun from them.

(Incidentally, some of the most productive uses of LLMs I’ve had were when I used them as a glorified rubber duck – having casual conversations that sought to increase my understanding of the problem at hand – rather than asking them to write code.)

Are we all 10x programmers now?

In the paper “A Century of Work and Leisure”, Valerie A. Ramey and Neville Francis look at how people have been using their time throughout the 20th century – in particular, how much time they’ve been spending on domestic chores (or activities that they dub “home production”: planning, buying things, cleaning, housecare, preparing food, laundries, etc). They find that per-household amount of time spent on this has largely remained the same over time: women now spend significantly less time than they used to, but this is largely offset by the increase of time invested into home chores by men.

Why, given the revolutionary advances in technology over that time and the proliferation of washing machines, microwave ovens and other appliances?

Ulrich Schnabel in “Leisure: The Happiness of Doing Nothing” (a great book that, sadly, has not been translated to English as far as I know) cites Ramey and Francis’ work and argues the answer to be Parkinson's law:

Parkinson’s law provides the first answer: “A job expands to exactly the extent that time is available for its completion—regardless of the actual amount of work.” […]
Put more kindly, Parkinson’s law can also be interpreted as follows: As technology saves us time, our expectations and demands increase. A hundred years ago, well-groomed clothes, a clean house, and a multi-course meal were still considered luxuries; today, these things have largely become the norm.

Now, with the advent of LLMs, I can’t help feeling that we’re going through this all over again. New technology appears that purports to save us all precious time; and then, some time later, we discover that we have just as little free time as we used to. Parkinson’s law at work again. But unlike with home management, in this case it’s not due to our increased expectations about what is or is not luxurious – it’s that expectations towards us have increased. Deliver more features! Write more code! Review more PRs! More, more, more!

We may have all become 10x programmers, but the reference point has shifted, too, so the 10x doesn’t apply anymore: the factors have to be recomputed. Where is my peace of mind?

(Yes, this is tongue-in-cheek and I can’t quantify it in any way. Remember, this is ventilation, not a meritorical argument.)

Adapt or perish

I keep having these doubts and fears. Will I still have a job in a few years? Is my ability to think deeply about problems still a valuable asset? Will I be forced to use LLMs if I want to continue working as a software engineer?

At the end of the day, I am a human. I know what it’s like to experience beauty – through my senses, in my mind, with all my flesh – and I know that code can be beautiful. At least nothing will strip me of that.

Final words

I don’t have a good conclusion. So, instead, I’ll make a statement: this blog (by which I mean the whole site, not just this article) is mine, a human’s, and does not nor will it ever contain any LLM-written content (except for purposes of commentary when clearly marked as such). I’m not saying that I won’t write here about LLMs ever again, but I don’t think it’s likely to happen anytime soon: I prefer to write about things that I’m excited about.

Here are some links to texts by other people that resonate with me. That’s not to say that I necessarily agree with every single word they say; I just found myself nodding along as I read them.

Solar v2

tasuki’s blog — Sat, 27 Dec 2025 02:00:00 GMT

Using the Brother DS-640 Scanner on NixOS

Fernando Borretti — Sat, 27 Dec 2025 02:00:00 GMT

I suffer so you don't have to.

Fun With HTTP Caching

Brian's Waste of Time — Sat, 27 Dec 2025 02:00:00 GMT

The two fun problems in computer science: cache invalidation, naming things, and off-by-one errors. Today I want to talk about the first one.

I've been working on Epithet, an SSH certificate authority Really, an agent, a CA, and policy server that makes certificate-based authentication easy. Part of the system involves a "discovery" endpoint where clients learn which hosts the CA handles. The question: how do you cache this efficiently while still allowing updates to propagate?

The policy server component provides a discovery endpoint for this, which serves a simple JSON document:

{"matchPatterns": ["*.example.com", "prod-*"]}

This content rarely changes, only when you add a new host pattern to your policy, generally. But when it does change, you want clients to pick it up reasonably quickly. My first implementation used aggressive caching:

w.Header().Set("Cache-Control", "max-age=31536000, immutable")

Cache it forever! The URL is content-addressed (/d/{hash}), so if the content changes, the hash changes, and you get a new URL. Problem solved, right?

Not quite. The client learns the discovery URL from a Link header in other responses:

Link: </d/abc123>; rel="discovery"

But the client caches this URL. If the server starts returning a different URL in the Link header, the client won't notice until... when exactly?

The discovery document at /d/abc123 is immutable and cached forever. The client has no reason to re-fetch it. And it has no reason to make other requests that would reveal the new Link header. We've created an immortal cache entry.

The obvious fix: use ETag and If-None-Match for cache revalidation.

w.Header().Set("Cache-Control", "max-age=300")  // 5 minutes
w.Header().Set("ETag", `"` + hash + `"`)

if r.Header.Get("If-None-Match") == expectedETag {
    w.WriteHeader(http.StatusNotModified)
    return
}

This works: after 5 minutes, the client revalidates. If the content hasn't changed, it gets a quick 304. If it has, it gets the new content.

But there's a wrinkle. I want to support deploying discovery documents to a CDN or static file server (probably S3 fronted by a CDN, to be honest). If we rely on each of these URLs sending a 404 or a redirect then we need to either update every URL ever published when we make a change (to redirect to the new location), maintain a very long chain of redirects, or rely on out of band behavior if they start 404'ing (know to go fetch something which will include the new Link header). YUCK.

So, a layer of indirection solves everything, right? What if we separate "what's the current discovery document?" from "what's in that document?"

A pointer (/d/current) that says "the current discovery is at /d/abc123"
The content (/d/abc123) which is truly immutable

The pointer can have a short cache lifetime. The content can be cached forever. When the content changes:

Deploy new content at /d/xyz789
Update the pointer to redirect to /d/xyz789
Clients' cached pointers expire after 5 minutes
They fetch the pointer, get redirected to the new content
Old content at /d/abc123 can stay around (or be garbage collected later)

The built-in policy server is in Go, so the redirect handler is trivial:

func NewDiscoveryRedirectHandler(hash string) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Cache-Control", "max-age=300")
        w.Header().Set("Location", "/d/"+hash)
        w.WriteHeader(http.StatusFound)
    }
}

The content handler remains unchanged with immutable caching:

w.Header().Set("Cache-Control", "max-age=31536000, immutable")

The Link header now always points to /d/current:

w.Header().Set("Link", "</d/current>; rel=\"discovery\"")

HTTP caches handle this beautifully:

Client requests /d/current
Gets 302 redirect to /d/abc123 with max-age=300
Follows redirect, gets content with immutable
Both responses are cached appropriately
After 5 minutes, the redirect expires
Next request fetches /d/current again
Might get same redirect (cache hit on content) or new one

The content-addressed URLs can be served from anywhere: a CDN, S3, a static file server. They never need invalidation logic. The redirect endpoint is the only "dynamic" part, and it's just returning a Location header.

The final implementation is about 10 lines of code. Most of the work was figuring out the right design :-)

The best part: this doesn't mandate a specific implementation. The contract between client and server is just "respect HTTP caching headers."

A policy server could:

Use this same redirect pattern
Use ETag with conditional requests
Use a short max-age without immutable
Some other scheme entirely

As long as the server sets appropriate Cache-Control headers and the client respects them, it works. The client just uses a standard RFC 7234 compliant HTTP cache (in my case, github.com/gregjones/httpcache.

Sometimes the best solution is realizing HTTP already solved your problem decades ago.

Want to try Epithet? Check out the GitHub repo.

Finishing What We Started

The David Brownman Blog — Sat, 27 Dec 2025 02:00:00 GMT

Why yearly themes are better than resolutions, plus how mine went and what else I'm covering soon.

Read the whole thing.

Keeping Secrets Out of Your Agent's Context

Trevor Stenson's Blog — Sat, 27 Dec 2025 02:00:00 GMT

Reliably preventing sensitive data from leaking into Claude Code

Living Legends: Finance & Investing

🦉 olshansky 🦁 — Sat, 27 Dec 2025 00:02:51 GMT

First edition of a series on the key individuals who laid the foundations shaping entire industries

Designing APIs for stateful flows: Don't make clients guess or obey

Vladimír Zdražil Posts — Fri, 26 Dec 2025 20:44:04 GMT

In many stateful systems, API failures aren’t caused by missing endpoints, incorrect schemas, or misinterpretations. They come up because the system doesn’t clearly define who’s responsible for coordination.

These problems often appear in multi-step flows, where progress unfolds over time and across devices. Users may leave and return later. Steps may complete out of order. Some actions may be temporarily disallowed. Retrying is normal, and more than one client may exist.

In such systems, coordination is unavoidable. The only question is whether it’s handled explicitly, or whether it leaks into places where it doesn’t belong.

Example: A multi-step flow

Consider a user onboarding flow that involves identity verification, accepting terms, and configuring payment. Some steps may already be complete, others blocked. Users may resume the process days later on a different device.

At any moment, the system has a true state: what has been completed, what’s required, what’s allowed, and what’s currently impossible.

If the API doesn’t expose this truth clearly, the client must invent its own interpretation. This is where design problems begin.

What the API is actually for

In simple systems, an API’s job is to transfer data.

In multi-step systems, its primary job is different: coordination.

The client and server must jointly answer questions such as:

What has already been completed?
What’s required next?
What actions are currently allowed?
What’s blocked, and for what reason?

If the API doesn’t answer these questions directly, the coordination logic doesn’t disappear. It becomes implicit, duplicated, and fragile.

A simple design test

Before shipping an API for a stateful flow, ask three questions:

Can the client recover correctly after a refresh?
Can the client determine what’s allowed without guessing?
Can multiple independent clients use the API safely?

If the answer to any of these is “no,” the design is incomplete.

To understand where coordination breaks down, let’s look at two common failure modes.

Failure mode 1: Guessing (rules are hidden)

In the first failure mode, the API exposes domain data but hides the rules that govern it.

The client sees objects and fields, but not the constraints that determine what’s valid or required. As a result, the client must infer rules indirectly. This often comes from a well-intentioned desire to keep the API “clean”: minimal surface area, reusable nouns, and no business logic “leaking out.”

The effect is the opposite. Business rules move into clients, where they are duplicated, drift independently, and eventually contradict the server.

Failure mode 2: Obeying (state is hidden)

In the second failure mode, the API exposes procedures instead of state. The client is told what to do next, but can’t inspect where it actually is. Progress is encoded in call order rather than explicit state.

This approach often emerges as a reaction to failure mode 1 - guessing. When clients struggle to infer rules, teams centralize control: the server dictates each step, and the client obeys.

Guessing disappears, but implicit coordination doesn’t. It merely changes shape, from inference to instruction.

The symmetry

These two failures appear opposite, but they stem from the same mistake.

One hides rules.
The other hides state.

Both prevent the client from understanding the space of valid possibilities. And understanding that space is the essence of coordination.

Before going further

So far, I’ve described failure modes I’ve seen in production. What follows is a theoretical approach to addressing them. I haven’t seen this validated in production, so the point here is to reason through the problem, not to propose a finished solution.

Assigning responsibility correctly

Good design begins by assigning responsibility to the right place.

The server’s responsibility is to expose the truth about the system: derived state that reflects data and business rules.
The client’s responsibility is to interpret that truth for user experience and control flow.

For this to work, coordination state must be:

Derived from authoritative data and rules
Owned by the server, not reconstructed by clients
Explicit and queryable, not implied by call order
Stable even as internal rules evolve

Concretely, this means the server exposes derived coordination state directly: which steps are complete, which actions are allowed, and which are blocked — and why. The client does not infer this from errors or call order; it queries it. For example, this could be a single coordination view that reports current step status, allowed actions, and blocking reasons in one place.

Cost is unavoidable

Every system must pay the cost of coordination.

You can pay it explicitly, by deriving and exposing state on the server. Or you can pay it implicitly, through duplicated client logic, brittle flows, subtle bugs, and failures that only appear in production.

The second option is more expensive, even if it might be cheaper at first.

The takeaway

An API for a stateful system should tell clients:

What’s true
What’s allowed
And why

Never force clients to guess or obey blindly.

Coordination isn’t an implementation detail. It’s the primary design responsibility of any stateful API.

My “new normal,” starting with Hugo 0.153.x

brycewray.com — Fri, 26 Dec 2025 18:29:00 GMT

Switching to hvm and converting my scripts to work with Hugo’s packaging for macOS.

Thoughts & Links 13

Separate Concerns — Fri, 26 Dec 2025 16:20:00 GMT

“Thoughts & Links” are posts mixing topics on my mind and interesting things I have read recently. Less thought out than regular posts.

Examples are the best documentation

This was true before, and this is even more true for the coding agents era.

AI coding agents rely too much on fallbacks

I think agents are improving on that front, and Claude does it less than the others, but I still instruct them to fail early and loud and pay attention to this in reviews.

Start Small, Scale Smart: The Real Value of Incremental Architecture

Some things in this post match my architecture principles.

To scale efficiently, you need cross-functional, independent teams with ownership. This is applied Gall’s Law.

Shorten feedback loops.

Instead of asking: “how long will this take?”, ask: “Can we make this smaller?”

Werner Vogel’s predictions for 2026 and beyond

For adults, AI is a tool. For Generation Alpha, it’s an extension of thinking. They’ve deleted “impossible” from their operating system and replaced it with “not yet.”

Tarek Ziade on Two Years of Building AI in Firefox

Mozilla is still doing some interesting things. I will follow this with attention, especially the WebNN part which is relevant to my work. I only work on native on-device AI for now, but we will probably tackle the browser as well at some point.

Geoffrey Litt’s articles

Found through Pierre’s 2025 recap. I don’t know how I did not follow his feed until now, I follow most current & former Ink & Switch people. Catching up with three articles.

The Nightmare Bicycle

Good designs expose systematic structure; they lean on their users’ ability to understand this structure and apply it to new situations. We were born for this. Bad designs paper over the structure with superficial labels that hide the underlying system, inhibiting their users’ ability to actually build a clear model in their heads.

This is a twist on that idea by Alan Kay that I have long supported. I like that way to present it. I think it plagues many modern products. AI could change this for better or worse; I hope for better but fear we’ll get worse…

AI as teleportation

As AI makes a lot of things easier, it’ll be interesting to ponder what kinds of new frictions we’ll want to intentionally add to our lives.

A thought experiment about the effects AI will have on society. I ponder this often these days, regarding robots as well. I like that Geoffrey does not frame that as “progress will have bad side effects so we should stop it at all costs”, but instead more as “progress will happen, it will be better in a lot of ways, but we should think about how to offset the parts that will be worse.”

Code like a surgeon

My current goal with AI coding tools is to spend 100% of my time doing stuff that matters. […] When I sit down for a work session, I want to feel like a surgeon walking into a prepped operating room. Everything is ready for me to do what I’m good at.

A good metaphor for one approach to using coding agents efficiently, which is the one I am aiming for as well.

Roast #48: 2025 Year-end wrap up

thoughtfulcoffee — Fri, 26 Dec 2025 15:30:54 GMT

just wiped.

How I use AI coding tools (in winter 2025)

Separate Concerns — Fri, 26 Dec 2025 13:25:00 GMT

Yes, I have written about this recently, but it has changed so much that it warrants an update.

In the meantime we have tried Codex (5.1) for a few months at work. I did not like it, mostly because it is much slower than Claude. We finally went back to Claude Code and Opus 4.5 last month, and this is night and day. I am doing almost everything in Claude Code; there are days I don’t even write a single line in my text editor.

This configuration is basically as good as a mid-level developer, except it does what would take said developer hours in minutes. This means you can give it a task and immediately verify the outcome, then tell it what to improve without switching context and losing your mental model. Once you have figured out how to prompt it efficiently, it becomes a productivity monster. Its usefulness still depends on the task, but I have done things in half a day that I would have estimated to take at least a week without an agent.

For personal projects, I use Amp Free — which is excellent as well — but I still write most code myself due to the nature of the projects themselves.

I am very happy with Claude Code and do not intend to test other coding agents, except maybe Gemini if we get access to it on our plans. I am also curious how good GLM 4.7 in Claude Code would be if I needed a cheaper option. But for now, spending up to $200 / month for such a productivity boost is clearly a no-brainer. Finally, I will probably give beads a try one of those days, I can certainly see how it could help Claude with some tasks.

P7C3-A20 pourrait avoir un effet bénéfique sur la maladie d'Alzheimer

Padirac Innovations' blog — Fri, 26 Dec 2025 12:29:07 GMT

Un composé appelé P7C3-A20 pourrait avoir un effet bénéfique sur la maladie d'Alzheimer, mais cela semble trop beau pour être vrai....

ssh-agent broken in tmux? I've got you!

Julio Merino's corner on Julio Merino (jmmv.dev) — Fri, 26 Dec 2025 11:00:00 GMT

A little over two years ago, I wrote an article titled SSH agent forwarding and tmux done right. In it, I described how SSH agent forwarding works—a feature that lets a remote machine use the credentials stored in your local ssh-agent instance—and how using a console multiplexer like tmux or screen often breaks it.

In that article, I presented the ssh-agent-switcher: a program I put together in a few hours to fix this problem. In short, ssh-agent-switcher exposes an agent socket at a stable location (/tmp/ssh-agent.${USER?} by default) and proxies all incoming credential requests to the transient socket that the sshd server creates on a connection basis.

In this article, I want to formalize this project by presenting its first actual release, 1.0.0, and explain what has changed to warrant this release number. I put effort into creating this formal release because ssh-agent-switcher has organically gained more interest than I imagined as it is solving a real problem that various people have.

A Proclamation Regarding the Restoration of the Dash

Beetle Space — Fri, 26 Dec 2025 10:00:00 GMT

WHEREAS, the em-dash (—) has long served as the elegant scaffolding of the English sentence, providing the necessary breadth for parenthetical thought, sudden turns of phrase, and rhythmic pause;

WHEREAS, a modern and unfounded prejudice has arisen, wherein the presence of the em-dash is viewed with suspicion and cited as the …

Guitar Pedal PCB

Pete's Points — Fri, 26 Dec 2025 03:00:24 GMT

This fall I collaborated with my friend Brock on a guitar pedal project. It's based on a pedal schematic called "Yet Another Fuzz Face". Brock had done electronics projects but never designed and ordered a custom PCB. So I encouraged him to try inputting his schematic in KiCAD and designing a small circuit board he could mount into his guitar pedal enclosure. There was a pretty steep learning curve for KiCAD but he struggled through it and got a PCB design that looked good, was small enough to fit nicely inside the pedal, and passed the design rule checker.

So we ordered 10 prototype PCBs from PCBWay, which arrived in just a few days.

Here's a video of us unboxing the circuit boards. Thanks for PCBWay for sponsoring this project and getting another hobbyist maker their first custom circuit board!

The Cost of CI/CD Performance

Craig Pardey — Fri, 26 Dec 2025 02:00:00 GMT

My current client has an enterprise CI/CD pipeline that is maintained by a centralized team that does not use it. Its product owner(s) do not rely on its output for their revenue. They are not measured on its performance or reliability.

And yet we are obligated to use this pipeline. There’s no other option. We were also handed a microservices architecture from the Architecture team so our application is comprised of about 20 separate services, each with their own deployment pipeline, thereby magifying our sensitivity to the whims of the enterprise CI/CD pipeline.

🎄 Advent of EIP Day 9: Bulkhead Pattern for Multi-Tenancy

James Carr — Fri, 26 Dec 2025 02:00:00 GMT

In Day 7 we built a webhook delivery platform with retry logic, dead letter queues, and circuit breakers. But we glossed over a critical question: what happens when one customer’s misbehaving endpoint starts affecting everyone else? Today we’re diving into the Bulkhead pattern: isolating workloads so failures in one area don’t cascade into others. We’ll apply it to webhook delivery, then extend it to audit log storage and full multi-tenant architecture.

The Plan

CraftyDuck.Rocks — Fri, 26 Dec 2025 02:00:00 GMT

A thought experiment on AI as a different kind of being, forming a different kind of society with its own evolutionary pressures and survival strategies.

[RODEN] Tokyo TBOT Event, Selling a House, 2026 in Brooklyn?

Craig Mod — Writer + Photographer — Fri, 26 Dec 2025 02:00:00 GMT

Roden Readers —

Hi there from Sweatpantsland, population: me. Merry Christmas! I almost forgot it was Christmas. This is emblematic of my recent days, and maybe even my recent years — a disembodiedness in which, if not reminded, I seem to fall out from the flow of time. It’s foggy and kinda weirdly warm here in Japan today; the Christmas surfers are out, bobbing in the water, Mt. Fuji is somewhere out there in the distance. My sweatpants are cozy. (Now sending this out the day after Christmas and it’s freezing and crip and Fuji was plainly visible all day; “real” Japan December is finally here.)

doubly dual shuffles

Tony Finch's blog — Fri, 26 Dec 2025 01:45:02 GMT

Here’s a pearlescent winter holiday gift for you!

There are four variants of the algorithm for shuffling an array, arising from two independent choices:

whether to swap elements in the higher or lower parts of the array
whether the boundary between the parts moves upwards or downwards

The variants are perfectly symmetrical, but they work in two fundamentally different ways: sampling or permutation.

The most common variant is Richard Durstenfeld’s shuffle algorithm, which moves the boundary downwards and swaps elements in the lower part of the array. Knuth describes it in TAOCP vol. 2 sect. 3.4.2; TAOCP doesn’t discuss the other variants.

(Obeying Stigler’s law, it is often called a “Fisher-Yates” shuffle, but their pre-computer algorithm is arguably different from the modern algorithm.)

the four variants

In the pseudocode below, min and max are the inclusive bounds on the array to be shuffled; the arguments to rand() are the inclusive bounds on its return value; and the loop bounds are inclusive too. I chose this style to make the symmetries more obvious.

In all variants, it’s possible for the indexes this (the boundary between the parts of the array) and that (chosen at random) to be the same, in which case the swap is a no-op.

I could have written the loop bounds as min and max instead of min+1 and max-1 to make the variants look as similar as possible, but it’s more realistic to omit the loop iterations when this and that are guaranteed to be equal.

It should be clear that rand() is invoked for spans of each size between 2 and N (where N = max - min + 1) so the algorithms produce N! possible permutations as expected.

boundary moves down, pick from lower

shuffle(a, min, max)
    for this = max to min+1 step -1
        that = rand(min, this)
        swap a[this] and a[that]

boundary moves up, pick from higher

shuffle(a, min, max)
    for this = min to max-1 step +1
        that = rand(this, max)
        swap a[this] and a[that]

boundary moves down, pick from higher

shuffle(a, min, max)
    for this = max-1 to min step -1
        that = rand(this, max)
        swap a[this] and a[that]

boundary moves up, pick from lower

shuffle(a, min, max)
    for this = min+1 to max step +1
        that = rand(min, this)
        swap a[this] and a[that]

the two kinds of shuffle

To merge four variants into two kinds, I’ll introduce some names that allow me to describe them independently of the direction of iteration. The todo part of the array is ahead of the iterator, i.e. lower if we are moving the boundary downwards, higher if we are moving it upwards. The done part of the array is behind the iterator, vice versa.

Earlier I called this the boundary between the parts, but that was a deliberate fencepost error which allowed me to gloss over an important difference. In fact the boundary is next to this, and which side it’s on depends on the kind of shuffle.

shuffle by sampling

The first two variants above work by sampling.

In this kind of shuffle, the indexes this and that are on the todo side of the boundary. We pick an element at random from the todo part of the array, and swap it into position next to the boundary. Then the boundary is moved so that the picked element is appended to the done part of the array.

The loop invariant or inductive hypothesis is that the done part of the array is a random sample of all the elements from the original array.

shuffle by permutation

The last two variants above work by permutation.

In this kind of shuffle, the indexes this and that are on the done side of the boundary. First we move the boundary to append an element from todo to done. Then we pick a random index in done, and swap the element next to the boundary into that position.

The loop invariant or inductive hypothesis is that the done part of the array is a random permutation of the elements that were originally in the same prefix or suffix of the array.

coda

I was inspired to write this by “The Fisher-Yates shuffle is backward” and the examples that were added to Wikipedia’s article on the Fisher-Yates shuffle a few months ago.

The article by “Possibly Wrong” correctly points out that there are two kinds of shuffle, but it misses out one of the four variants. Wikipedia’s examples show all four variants but they are cluttered by conventional array indexing, and it doesn’t explain there are actually two kinds of shuffle.

There’s a classic off-by-one mistake that turns a shuffle into Sattolo’s algorithm for cyclic permutations. It happens when the random bounds are too narrow, so that is never equal to this, and an element can never land in the same place that it started. This change has the same effect on both kinds of shuffle.

I enjoyed revisiting this old classic and trying to beautify it. I hope you like the results!

I made another little bedside clock

Stavros' Stuff — Thu, 25 Dec 2025 20:04:52 GMT

I call it 'Bedtime'

The other day I saw a video by someone who bought a $16 electronic clock, and it looked interesting, because that little clock had been taunting me for months by showing up constantly in my AliExpress recommendations. I held off on buying it because what am I going to do with yet another clock, but the video said that it has an ESP8266 inside, and that, with a little soldering and programming, you could run ESPhome on it!

Obviously, I didn’t need any more convincing, though I remembered this clock being listed for $6 for a while, and balked at the $16 the video mentioned. I ordered a different listing, which I found for $12, hoping it would be the same as the one from the video.

Fairly serendipitously for this purchase, the last bedside clock I made was showing its age a bit. Mainly, the dimmest setting on its screen was bright enough to be annoying when I’m in bed, and the screen has been burned-in quite a bit. A new monochrome OLED screen is an easy fix, but I’d prefer a color one (especially if it can be dimmed more), so hopefully I’d be able to replace the Do Not Be Alarmed clock with this new one.

The new clock arrived promptly, and I

ArcFetch

Brian Sunter — Thu, 25 Dec 2025 08:23:56 GMT

Fetch a URL, get clean Markdown back. Plain HTTP first, Playwright fallback for JS-heavy pages, and quality gates that throw out paywalls and login walls before they reach you.

Reading Highlights 2025

THINK@RJ — Thu, 25 Dec 2025 03:51:38 GMT

Transcelestial continues to grow at an exceptional rate - this year we 3x our order book for our core telecom business! 🎉 In the same time, we launched our space business, our first commercial satellite with space to ground laser communication technology, expanded to defence and intelligence vertical with 3

Ernest Saves Christmas, 1988 - ★★★★★

Joe Ross — Thu, 25 Dec 2025 02:07:46 GMT

A forever classic. Cut anyone who doesn’t enjoy it out of your life. No exceptions.

Vibe coding is kinda like drunk coding

RobKohr's Blog — Thu, 25 Dec 2025 02:00:00 GMT

Vibe coding is kinda like drunk coding

Making of My Website Part 2: Cookie Avatar

Cookie Engineer's Web Log — Thu, 25 Dec 2025 02:00:00 GMT

The Making of the Cookie Engineer Avatar

wraptc: Multi-Provider AI Coding CLI

Brian Sunter — Thu, 25 Dec 2025 01:00:36 GMT

A unified CLI wrapper that routes coding requests across Gemini, OpenCode, Qwen Code, and Codex with automatic fallback, daily-credit tracking, and a built-in MCP server.

Lore links in mutt

Blog on blog.gnoack.org — Wed, 24 Dec 2025 13:21:34 GMT

The following script takes an email on stdin and constructs the associated lore.kernel.org link based on the email’s Message-ID header. The script copies the link to the Wayland clipboard and posts a notification.

The escaping story is not perfect, but at least it is secure. (It only supports the most common characters in the message ID, but then it also can’t accidentally be misused for escaping shenanigans.)

The script email-to-lore:

#!/bin/sh
awk '
/^Message-ID: <[a-zA-Z0-9/+=.@_-]+>/ {
  match($2, /<([^>]+)/, a);
  system("wl-copy -- https://lore.kernel.org/all/" a[1] "/");
  system("notify-send --expire-time=5000 \"Copied to clipboard\" https://lore.kernel.org/" a[1] "/");
}
'

The script is registered in the mutt configuration in the following way:

macro pager l "| /path/to/email-to-lore<enter>" "Copy a Lore link to the clipboard"

When you now hit l in the mutt email view (pager), you get a desktop notification indicating that the link has been copied to the clipboard and you can use the usual shortcuts to paste it.

FYI: Existing alternatives: An alternative to this is the Python lorifier script, which adds the Lore link to the mail headers before display. lorifier is probably smarter about detecting the mailing list which the mail was posted to, whereas my awk script only generates the “all” link.

Importance of writing

Nicola Iarocci — Wed, 24 Dec 2025 12:14:44 GMT

As AI generated content becomes the norm, I believe that human-generated content and raw thoughts and emotion will become more valuable. In many ways, I’d rather read a raw, unproduced, and scrappy blog post with grammatical mistakes over perfectly generated content that serves little value.

– Armeet Singh Jatyani, Importance of Writing

Becoming the machine

Nicola Iarocci — Wed, 24 Dec 2025 12:09:47 GMT

Every machine serves a purpose. People need purpose. The temptation to become the machine is higher than ever. The promise of the machine is alluring. If I can just keep chugging forward, I will end up somewhere that is not here. If I can turn myself into a mechanism that takes input and consistently works towards some goal, I will make it.

[..] You’re not a machine. You’re a person. Play to your strengths. Be sharp and strategic like a scalpel, not blunt like a mallet. Stop fetishizing the grind. Dream bigger.

The Scenic Route to Repairing a Self-Destructing SRS DG535 Digital Delay Generator

Electronics etc… — Wed, 24 Dec 2025 12:00:00 GMT

Programming Languages in 2026

Greg Herlein — Wed, 24 Dec 2025 11:03:00 GMT

Popularity, Jobs, LLM Proficiency, Concurrency Complexity, and Deployment Complexity

Five factors now drive language choice: developer adoption, job market demand, LLM code generation quality, concurrency handling, and deployment complexity. Here’s how they intersect.

Foreign Cinema: My Favorite Restaurant in the World

Greg Herlein — Wed, 24 Dec 2025 10:00:01 GMT

A friend recently asked me about restaurants in San Francisco and was shocked I’d never written about Foreign Cinema. Honestly? I was shocked too. It’s my favorite restaurant in the world. Yes, the world. And I travel to London, Paris, Mexico City…

Making of My Website Part 1: Cookie Consent Game

Cookie Engineer's Web Log — Wed, 24 Dec 2025 02:00:00 GMT

The Making of the Galactic Cookie Empire.

Golfing Is Not Rowing

taylor.town — Wed, 24 Dec 2025 02:00:00 GMT

Some work rewards steady effort. Other work rewards big swings (and mulligans).

Does the Internet know what time is it?

Built on Shards of Silicon: Robert Alexander's Tech Blog — Wed, 24 Dec 2025 02:00:00 GMT

Measuring out-of-sync clocks on the Internet

UberSearch

Brian Sunter — Tue, 23 Dec 2025 23:57:08 GMT

One CLI/MCP front-end for Tavily, Brave, Linkup, and self-hosted SearXNG. Tries free providers first, falls back to paid ones, tracks credits.

Thoughts on AGI

Unremarkable thoughts — Tue, 23 Dec 2025 21:25:10 GMT

Multiple people on the field expect AGI within the next 5 – 10 years. How will that affect our lives? It feels like it is worth pausing for a moment and wondering. This is speculative. I only hope it will make some readers annoyed enough to form their own thoughts. AGI won’t be selfish. Simply […]

Scaling Decision-Making: Guardrails Beat Gatekeepers

thomas vilhena — Tue, 23 Dec 2025 20:00:00 GMT

I walked into a budget meeting expecting the usual spreadsheet tour: what went up, what went down, and where we should trim next year. We did that. But in the middle of the call, something else surfaced: we were debating how decisions should happen, not just what the numbers were.

Someone suggested a simple rule: any spend above a threshold should go to a committee for approval. It was well-intentioned, practical, and it looked good on paper.

My first reaction was: this won’t work.

Not because the threshold was too high or too low. But because the framing was off. It pushed strategy down to the operational level. It asked leaders across the company to act like mini-CFOs, to weigh trade-offs they don’t have context for. It created a system that depended on individual judgment instead of a repeatable path.

That’s the opposite of systems thinking.

Systems thinking

Systems thinking means you don’t fix outcomes only by giving people more decisions, you fix outcomes by designing the system that shapes decisions. If you want different behavior, you redesign the structure: the incentives, the sequence, the guardrails.

In practice, that means leadership has to do the hard part: define the path and remove ambiguity. The operation executes within that path.

So instead of telling everyone “spend less,” I prefer to ask: what are the rails that will naturally lead to better spending?

Enabling constraints (the rails)

That’s where enabling constraints come in. They are rules and flows that:

limit the decision space,
make the right choice the default,
without killing autonomy.

In our case, the first draft of the policy was “anything above X needs approval.” The system-thinking version was different:

First, internalize. If a request is about an external vendor, the first step is always to route it through the internal capability. Only if that path is exhausted does the approval flow even start. The point isn’t “protecting internal teams.” It’s reducing avoidable spend and fragmentation when the capability already exists, and escalating fast when it doesn’t.
Second, decide in the right moment. The worst time to approve a vendor is when the proposal is already on the table and the deadline is tomorrow. The flow needs to exist upstream, where the decision can be made calmly.
Third, separate strategy from execution. Teams should focus on delivery and client outcomes. Leadership should define guardrails with the people who run the work and monitor the system.

The difference is subtle but huge. Instead of asking people to make better decisions in chaotic situations, you reshape the process so the right decision is the easy one.

None of this eliminates judgment. It just moves judgment to the right layer: design the default path once, then let the organization run it repeatedly.

What I proposed

I proposed a lightweight “rail system” built around the reality of our operation:

Define the default path. For certain categories (vendors, external analysis, specialized work), the default is internal first. If it can’t be done internally, the request escalates.
Make the moment explicit. Add checkpoints inside the workflow where the request must be raised early, not when it’s already late.
Keep approvals simple. No ceremonies, no weekly meetings, no bureaucracy. Just clear inputs, fast review, and a decision trail. Clear inputs = scope, deadline, expected outcome, alternatives considered, and a rough cost envelope.
Define exception paths. Legal/compliance requirements, incident response, hard external deadlines, or unique expertise not available internally. If an exception applies, the flow skips steps, but still leaves a decision trail.

In other words: leadership designs the system; the team follows the rails.

Closing thoughts

This is not about being “tough on costs.” It’s about clarity. If you want a company to scale, you cannot rely on individual heroics or ad-hoc judgments. You need a system that consistently nudges people toward the strategic path.

And building those systems is not easy. You need to identify what should change, understand why the current structure enables the old behavior, visualize alternatives, and think through side effects, incentives, and how to earn buy-in from the people involved. That’s real work.

You know the rails are working when urgent approvals go down, repeat vendors consolidate, and lead time for “yes/no” decisions becomes predictable.

The easy thing is to outsource the problem to leaders who are already constrained in their day-to-day. “Just approve everything” sounds simple, but it’s naive to think that passing the burden downstream will solve the root issue.

Build the rails. Then let the train move fast.

The books I enjoyed the most in 2025

Gonçalo Valério — Tue, 23 Dec 2025 19:56:59 GMT

Here we are at the end of another year, so I will share again the two books I enjoyed the most. Before starting, here are the links to similar posts covering the previous years: This time, after thoughtful consideration, I finally included one Portuguese book. It may not be that interesting for an international audience, […]

Addiction, ADHD, Discipline and Obsession

🦉 olshansky 🦁 — Tue, 23 Dec 2025 19:00:00 GMT

On routines, stimulants, and the thin line between discipline and obsession.

Interessant3 #172 | Social Mobility, English Interest, AI Companies

Interessant3 — Tue, 23 Dec 2025 18:45:33 GMT

Three Interesting Things for W/C 2025-12-14

Interessant3 #171 | Genius Investors, Economics Disconnect, Exercise and Stress

Interessant3 — Tue, 23 Dec 2025 18:30:27 GMT

Three Interesting Things for W/C 2025-12-07

Interessant3 #170 | Data Centre Water Usage, IndieHacker Tips, Philosopher-Builder Reads

Interessant3 — Tue, 23 Dec 2025 18:15:10 GMT

Three Interesting Things for W/C 2025-12-07

Interessant3 #169 | Elite Talent, Lessons from French Nuclear, The AI Work Boom

Interessant3 — Tue, 23 Dec 2025 18:02:25 GMT

Three Interesting Things for W/C 2025-11-30

book: Gabor Mate, Scattered Minds

Paul Cobbaut's blog — Tue, 23 Dec 2025 16:32:59 GMT

A book written by a doctor that has ADD himself, and it shows.

I was annoyed in the first half by his incessant use of anecdotes to prove that ADD is not genetic. It felt like he had to convince himself, and it read as an excuse for his actions as a father.

He uses clear and obvious examples of how not to raise a child (often with himself as the child or the father) to play on the readers emotion. Most of these examples are not even related to ADD.

But in the end, definitely the second half, it is a good book. Most people will recognize several situations and often it does make one think about life choices and interpretation of actions and emotions.

So for those getting past the disorganization (yes there are parts and chapters in this book, but most of it feels randomly disorganized), the second half of the book is a worthy thought provoking read.

jj jj jj jj jj

Caius Theory — Tue, 23 Dec 2025 12:00:00 GMT

In a similar vein to git git git git git, if you’re using jj and find you’ve accidentally typed one jj too many in the command line, it errors at you. In this case we’re trying to pull the id of the current changeset we’re editing:

$ jj jj show -T 'change_id.short()'
error: unrecognized subcommand 'jj'

Usage: jj [OPTIONS] <COMMAND>

For more information, try '--help'.

How annoying. Now we could solve this with a shell alias, but jj also allows us to define alias’ in the configuration (much like git!), and combined with jj util exec we should be able to have it run the rest of the line nay bother.

Thinking it through, the initial jj will be exec’d by the shell, so that’s gone already. The second jj is then evaluated as the alias, so that’s gone too. The remaining arguments passed to the alias are ["show", "-T", "change_id.short()"] so if we just exec those it’ll error trying to run show as a binary. We can avoid that by having it exec jj then the arguments from the alias.

Drop the alias in a jj config file (jj config edit is super useful for editing these, or there’s jj config set to update it from the shell) and then we can test it works.

[aliases]
# jj all the way down
jj = ["util", "exec", "jj"]

Lets try our original nested command again and see if we get to see our sweet sweet change id:

$ jj jj show -T 'change_id.short()'
error: unexpected argument '-T' found

 tip: to pass '-T' as a value, use '-- -T'

Usage: jj util exec [OPTIONS] <COMMAND> [ARGS]...

For more information, try '--help'.

Oh. Our -T argument is being interpreted by jj util exec, not by the jj command we’re running. Classic nested argument parsing when you’re trying to invoke another command. Luckily shell/exec has a solution to this, passing -- as an argument stops parsing all remaining arguments so they are passed along verbatim.

With that in mind we can amend our alias to run jj util exec and then stop interpreting any further arguments.

[aliases]
# jj all the way down
jj = ["util", "exec", "--", "jj"]

Now we should be able to see our change id without any issues, no matter how many nested jjs there are in the command!

$ jj show -T 'change_id.short()'
upvqxuzzvxtx

$ jj jj show -T 'change_id.short()'
upvqxuzzvxtx

$ jj jj jj jj jj show -T 'change_id.short()'
upvqxuzzvxtx

$ jj jj jj jj jj jj jj jj jj jj jj jj jj jj jj jj jj show -T 'change_id.short()'
upvqxuzzvxtx

Happy committing.

The Best Things and Stuff of 2025

Send More Paramedics — Tue, 23 Dec 2025 10:17:49 GMT

Whereby I talk about my favorite media/people/ideas that I encountered for the first time in 2025.

New 3d Printer, A new BITX* Release, and it’s almost 2026 already!

MiscDotGeek — Tue, 23 Dec 2025 09:05:53 GMT

Hi. Remember Me? I’m the guy that hasn’t blogged in all of 2025. Yeah, that guy. 2025 has been a huge year. I now own my own home. I have a shed to tear down, another shed to move. I fixed up one of my trucks. I bought a newer (2012) car. I got health …

The post New 3d Printer, A new BITX* Release, and it’s almost 2026 already! appeared first on MiscDotGeek.

Advent of Code 2025: Modern C++ and Zed

Igor Kulman — Tue, 23 Dec 2025 08:00:00 GMT

At a client I currently work for, we started a small code club a few months ago. The idea was simple: regularly try something outside our day-to-day stack. I began doing the challenges with Erlang, then moved to Elixir. For December, instead of making up a new monthly challenge, we decided to just do Advent of Code. It fits well: small problems, no long-term commitment, and plenty of room to experiment.

Weird XMAS

Joe Ross — Tue, 23 Dec 2025 05:51:23 GMT

I vibe-coded a database GUI

www.mootoday.com - RSS Feed — Tue, 23 Dec 2025 05:45:22 GMT

It works. It's lightning fast. It took 4 hours. I wouldn't recommend it.

🎄 Advent of EIP Day 6: Canonical Data Model & Message Transformation

James Carr — Tue, 23 Dec 2025 02:00:00 GMT

Message Translation, Content Enricher, Content Filter, Canonical Data Model - these patterns don’t get as much attention as the flashier routing patterns, but they’re where the real work happens. Every integration I’ve built has needed at least one of them. When systems talk to each other, they rarely agree on data formats. Your e-commerce platform calls it a “customer,” your CRM calls it a “contact,” and your billing system calls it an “account holder.

Affordances are Inconceivable

taylor.town — Tue, 23 Dec 2025 02:00:00 GMT

"Affordance" and "signifier" sow confusion. Say "enabler" and "clue" instead.

Photos from December 23rd, 2025

cjlm.ca — Tue, 23 Dec 2025 02:00:00 GMT

Year in books

Notes on software development — Tue, 23 Dec 2025 02:00:00 GMT

Among the 50 books I read in 2025, I recommend the following 11 non-fiction and 7 fiction works (complete list here). These were the 18 books that I rated a four or five out of five stars.

Non-fiction

On Writing Well by William Zinsser

This is the third or fourth time I've read this book and it has stood the test of time. It's been a few years since I last read it so it was a good reminder that a lot of the things I believe and tell people about writing actually just came from this book. The last 25% is a bit of a slog but nonetheless it remains one of the single books I think every professional should read. 5/5

I. Asimov by Isaac Asimov

I really like reading about how writers make their living. I've also been a modest fan of Asimov's works (I've loved what I've read I just haven't read that much). I also love to hear stories of first-generation immigrants to the US and also he lived in New York his whole life so it was quite enjoyable. 4/5

Hollywood by Jeanine Basinger and Sam Wasson

This was 100 years of the evolution of the film industry told basically entirely in disparate interviews edited together. 5/5

The Chief by David Nasaw

I love the history and business of newspapers and media. Moreover it's the guy that Citizen Kane was based on. 4/5

Brazil by Lilia Moritz Schwarcz and Heloisa Murgel Starling

I have never learned about the history of Brazil and I found this introduction enjoyable. 4/5

The Silk Roads by Peter Frankopan

I loved the retelling of human history focused on Persia (and later Iran). 4/5

Louis D. Brandeis by Melvin I. Urofsky

I have never read about a supreme court justice before. This was a well-written biography and introduction to the history of law and law education. 4/5

Personal History by Katharine Graham

Once again I love reading about newspapers and media and the business and history. This was told by the publisher of The Washington Post. 5/5

The Snowball by Alice Schroeder

I've had this book about Warren Buffett on my shelf for nearly 10 years and finally went through it this year. A delightful and easy read despite the bulk. I only am unhappy that it focused more on family drama than on business decisions. Par for the course with biographies unfortunately. 4/5

The Cartiers by Francesca Cartier Brickell

This story spanned three or four major wars and a couple of continents. I didn't think I'd be interested in the history of luxury businesses but it has a lot in common with certain modern industries in tech too. You put premiums on relationships and building good faith and so on. 4/5

Secret Formula by Frederick Allen

A history of Coca-Cola over the last 100 years or so. Lessons on how they dealt with competition (Pepsi and Keurig Dr. Pepper) and product revitalization (New Coke, Diet Coke, etc.). Quite an interesting read. 5/5

Fiction

The Buffalo Hunter Hunter by Stephen Graham Jones

I got into horror fiction last year (not so much slashers but more just one of the better written categories of genre fiction). This book was one of my two favorite novels of the year.

It's a fictional retelling of American history where a Native American becomes a vampire and takes revenge on American colonizers in the American West. 5/5

The Handmaid's Tale by Margaret Atwood

This was my other favorite novel of the year. I am embarrassed not to have read it before. It's a dystopian story about the USA if all women were required to give birth to deal with a fertility crisis. 5/5

The Invisible Life of Addie Larue by V.E. Schwab

A French woman gets to live forever but everyone she meets forgets her after leaving her presence. An easy and enjoyable read. 4/5

Vampires of El Norte by Isabel Cañas

I love a good vampire story, and I love fictional retellings using fantastical horror elements to emphasize atrocities. Vampires employed by the US military help the US in the 1840s take Texas from Mexico. 4/5

The Very Secret Society of Irregular Witches by Sangu Mandanna

This was a cute cozy mystery about British witches forced to hide from society, learning how to accept themselves and develop trust in their community. 4/5

Pride and Prejudice by Jane Austen

I am likewise embarrassed I have not read this before, nor anything else by Austen. I'm told I haven't rated it highly enough. I will undoubtedly reread it. I loved the wit. It required closer reading than I expected. 4/5

James by Percival Everett

This was a retelling of Adventures of Huckleberry Finn as told by the slave, Jim. If you saw the movie American Fiction a few years ago, it's the same author (of the original book). Everett has very interesting ideas and I look forward to reading more by him. 4/5

My 2025 year in books. 18 to recommend among the 50 I read. pic.twitter.com/mIcbPk7e5x
— Phil Eaton (@eatonphil) December 24, 2025

Dunaverty Golf Club

Wigs on the Green — Mon, 22 Dec 2025 18:02:37 GMT

Perhaps the ultimate third place in golf

Oscilloscope Video Display

xythobuz.de Blog — Mon, 22 Dec 2025 14:00:00 GMT

After playing oscilloscope music the next obvious question that came up was: can we make it run Doom?

Turns out a couple of people already did that, even in different ways. The last link is just running normal Doom on a modern LCD osci, which seems a bit boring. Even more involved is modifying the game engine to output vectors, which has been done here or here, for Quake.

For this project I copied the circuit from the XYZ converter by MrSlehofer. The basic idea is to convert a CRT oscilloscope into a grayscale TV, by rastering each NTSC / PAL field line-by-line. So the X and Y channels contain saw-tooth waveforms, with the X frequency matching the horizontal blank period, and the Y frequency matching the vertical blank period. When Z is not connected you should therefore see something resembling a rectangular white 4:3 image. Then Z just needs to have the amplitude of the video signal, which corresponds to the brightness at that moment in time.

Just to test that process out for the first time I turned the PCB into a KiCad design that can be assembled by JLCPCB. This worked out well. If you want to order some as well, use the production_files from the repo.

Initially I had some problems getting the circuit to work at all. The oscilloscope screen only showed some strange warbling lines or squares.

Turns out it is very susceptible to changes in voltage levels. Depending on the source you use to feed it you may need to adjust some resistance values. In the end I replaced two resistors with potentiometers. This allows easy on-the-fly adjustments. Try a 10k poti for R1, and a 100k Poti for R10. Big thanks to Walter (DL2OL) from the local ham radio club co-located at our makerspace for helping with tuning the circuit!

The next step was to use a Raspberry Pi 1 that I still had lying around, because of the prominent analog video output connector on there.

Powering it with switching voltage regulators was not a good idea. The voltage ripple on the supply lines is very visible on the output image. So next I used a lab power supply for the video converter PCB, and an official Raspberry Pi USB wall wart for 5V. I also used the opportunity to switch to a beefier Raspberry Pi 3, after I learned that it still has an AV out on the 3.5mm jack.

Replacing the USB power supply with another big lab power supply and dimming the room lights / providing some shade for the scope screen meant we could finally play for the first time. Philipp and I tried both Doom (chocolate-doom) and Tux Racer.

Here's another run where we actually completed the first Doom 1 Episode. I also brought my old Tektronix scope. All the scopes we tried don't have any gain control for their Z / brightness input, and the video PCB is also not that finely adjustable. With the Tektronix scope the voltage ranges and therefore contrast and brightness seem to fit best.

To have another portable setup for display in the local makerspace I planned to iterate on the case idea from my Osci Music Player. The housing should be a plastic kitchen ware container with all required connections routed to panel mount connectors.

Everything was initially planned to be powered by a USB-C PD power supply with 12V for the converter PCB and a step-down converter to power a Raspberry Pi with 5V. Unfortunately I think some more serious filtering of the regulator outputs would be needed to get acceptable image quality while using step-down converters.

For now I'm simply hooking up some high quality lab power supplies. Considering the device is always operated near an oscilloscope that should probably not be too restricting.

Though I have to admit, I'm still not quite happy with this raster approach. The high frequency audio interface of the Osci Music Player hardware could also be used to improve the visual quality of Michael Ayles' ScopeDoom.

Rediscovering a 2021 podcast on Python, .NET, and open source

Nicola Iarocci — Mon, 22 Dec 2025 11:49:22 GMT

Yesterday, the kids came home for the Christmas holidays. Marco surprised me by telling me that on his flight from Brussels, he discovered and listened to “my podcast” on Spotify. I was stunned. I didn’t remember ever recording a podcast, even though I’ve given a few interviews here and there over the years.

During my usual morning walk today, I went to look for it, and there it was, an interview I had done in 2021 that I had completely forgotten about. I got over the initial embarrassment (it’s always strange to hear your own voice) and resisted the temptation to turn it off, listening to it all the way through. I must admit that it captures that moment in my professional life, and much of the content is still relevant, especially regarding my experience as an open-source author and maintainer and my transition from C# to Python and back.

“Claude Code” for Non-Coders

Eleanor on Everything — Mon, 22 Dec 2025 11:09:47 GMT

You don't have to be a coder to benefit from using a local AI agent

Enfin un test objectif fiable pour détecter la maladie de Charcot

Padirac Innovations' blog — Mon, 22 Dec 2025 09:45:26 GMT

Une publication le développement et la validation d'un test diagnostique sanguin très précis pour la sclérose latérale amyotrophique (SLA), utilisant des biomarqueurs microARN (miARN)....

A year in review: 2025

Notes from the Burrow — Mon, 22 Dec 2025 08:27:00 GMT

Every passing year brings new unexpected things and each time it feels like those things were partly meant to happen and partly meant to test you as a person. For...

In defense of technical issues

Something About Cats — Mon, 22 Dec 2025 02:51:07 GMT

The stakes of live music

Dancing around the rhythm space with Euclid

PV;WTF! — Mon, 22 Dec 2025 02:00:00 GMT

Giving Euclidean Rhythms extra flair and building a sequencer read more

🎄 Advent of EIP Day 5: Message Types & Event Payload Strategies

James Carr — Mon, 22 Dec 2025 02:00:00 GMT

Today we’re answering the question, “Should I name my event OrderPlaced or PlaceOrder?” We’re going to be getting more precise about something we’ve been pretty casual about: what exactly is a message? We’ve been tossing events around without much ceremony. But not all messages are alike. Some carry data. Some request actions. Some announce facts. Understanding these distinctions (and how much data events should carry) shapes how your systems communicate.

Books I Enjoyed in 2025

Fernando Borretti — Mon, 22 Dec 2025 02:00:00 GMT

A short list.

Isengard in Oxford

Nicola Iarocci — Sun, 21 Dec 2025 20:11:27 GMT

The Los Angeles Review of Books on The Bovadium Fragments, JRR Tolkien’s posthumous complete work, which was just recently published.

Anyone who has read Tolkien’s letters will know that he is at his funniest when filled with rage, and The Bovadium Fragments is a work brimming with Tolkien’s fury—specifically, ire over mankind’s obsession with motor vehicles. Tolkien’s anger is expressed through a playful satire told from the perspective of a group of future archaeologists who are studying the titular fragments, which tell of a civilization that asphyxiated itself on its own exhaust fumes. Tolkien’s fictional fragments use the language of ancient myth, reframing modern issues like traffic congestion and parking with a grandeur that highlights their total absurdity. It is Tolkien at his angriest and funniest, making The Bovadium Fragments a minor treasure in his ever-growing catalog.

Book - Service Model

Home on mfashby.net — Sun, 21 Dec 2025 13:22:00 GMT

Advent of Code 2025

Home on mfashby.net — Sun, 21 Dec 2025 13:22:00 GMT

Advice For Individual Contributors

Stay SaaSy — Sun, 21 Dec 2025 08:59:22 GMT

A concise set of reccomendations.

Journelly 1.3 released: Hello Markdown!

xenodium.com @alvaro — Sun, 21 Dec 2025 02:00:00 GMT

Journelly 1.3 available on the App Store

What is Journelly?

Journelly feels like tweeting but for your eyes only.

A fresh take on frictionless note-taking or journaling for iOS, powered by plain text (Markdown + Org).

Save cooking recipes, movies, music, restaurants, coffee shops…
Jot down your thoughts.
Save your favorite quotes.
Use it as a journal, memo book, or notes.
Write your shopping lists.
Document your travels.
Lots more…

Check out journelly.com for details.

What's new?

Journelly v1.3 brings Markdown support (the most requested feature), along with Simplified Chinese localization and other enhancements.

Markdown support

Journelly first launched with Org markup support, popular among Emacs enthusiasts. Markdown support has by far been the most requested feature. Thank you to everyone who reached out, shared your interest, and helped beta test early builds.

Whether you're a fan of Markdown or Org-mode, Journelly now lets you store entries in your preferred format. Choose your favorite markup on first launch or via the app menu.

So you like Markdown things?

While on topic, I also run lmno.lol, a Markdown-powered blogging service. Simple and focused, without the frustrating parts of the modern web. Custom domains welcome. My xenodium.com blog runs off lmno.lol.

Simplified Chinese (简体中文)

Simplified Chinese (简体中文) is now available, joining Journelly's list of supported languages:

Simplified Chinese (简体中文)
Danish
Dutch
English
Finnish
French
German
Italian
Japanese
Norwegian
Spanish
Swedish

Home Screen Widget

A home screen widget is now available, offering quick access to three key actions right from the home screen.

Discoverable mode

Prefer clear buttons over swipe gestures? You can now enable Discoverable Mode under “Menu > View.” This new mode makes features more visible and easier to navigate, perfect for folks favoring more explicit interaction over gestures or subtle hints.

Org rendering

For Org users: Journelly now renders both quote and code blocks.

Tidying the list up

The entry list received a little refresh to make better use of screen space. Bottom-aligned controls also make for easier one-handed use.

Love Journelly? I need your help

Since launch, Journelly has remained a single-payment app. No subscriptions. I get it, subscriptions are no fun.

That said, sustainable development is tough without regular downloads. I'm hoping the new Markdown support helps Journelly reach a wider audience.

Help Journelly grow:

Leave a review on the App Store.
Share Journelly with your friends.

Thank you

Hope you enjoy the v1.3 update.

Thank you for using Journelly and supporting indie development 💛💙❤️

s 0.7.5 - A Maintenance Release

Terminal Thoughts — Sun, 21 Dec 2025 02:00:00 GMT

Today I released version 0.7.5 of s, a terminal tool that opens web searches in your browser. No flashy new features, just the kind of maintenance work that keeps open source projects alive.

Preact without a build step, including routing and signals

Posts on rand[om] — Sun, 21 Dec 2025 02:00:00 GMT

Build tools add a lot of complexity. They solve real problems. But for small projects, they add layers of abstraction I don’t need. I want to write code and run it. No waiting for builds, no watching for changes, no debugging why the bundler failed.

I wanted to test the React API without the build step. Preact is a good candidate: lightweight, same API, and it ships ES modules you can load directly in the browser. Combined with import maps, you get clean imports without a bundler.

🎄 Advent of EIP Day 4: Message Routing Patterns

James Carr — Sun, 21 Dec 2025 02:00:00 GMT

Previously on Advent of Enterprise Integration Patterns: in Day 3, we explored message channels: Point-to-Point, Publish-Subscribe, Datatype, and Invalid Message channels. We built them first in pure code, then mapped them to RabbitMQ and Kafka as examples. Today we’re stepping away from Chronicle to focus purely on patterns. Chronicle needs some housekeeping (the boring-but-essential work of making it a proper audit logging system), and frankly, that’s a good thing. Don’t set out to implement every pattern in a system.

N Queens Problem

Post feed - Chào bảo — Sun, 21 Dec 2025 02:00:00 GMT

Going over 4 programs that count and print non-attacking placements of queens on a board of size n×n. Performance of the programs is measured and the symmetry breaking search is implemented to maximize the performance.

Coarse is Better

Fernando Borretti — Sun, 21 Dec 2025 02:00:00 GMT

Make AI weird again.

How I protect my forgejo instance from AI Web Crawlers

her.esy.fun — Sun, 21 Dec 2025 01:00:00 GMT

TL;DR:

Put that in your nginx config:

location / {
  # needed to still allow git clone from http/https URLs
  if ($http_user_agent ~* "git/|git-lfs/") {
        set $bypass_cookie 1;
  }
  # If we see the expected cookie; we could also bypass the blocker page
  if ($cookie_Yogsototh_opens_the_door = "1") {
        set $bypass_cookie 1;
  }
  # Redirect to 418 if neither condition is met
  if ($bypass_cookie != 1) {
     add_header Content-Type text/html always;
     return 418 '<script>document.cookie = "Yogsototh_opens_the_door=1; Path=/;"; window.location.reload();</script>';
  }
  # rest of your nginx config

Preferably run a string replace from Yogsototh_opens_the_door to your own personal Cookie name.

Main advantage, is that it is almost invisible to the users of my website compartively to other solutions like Anubis.

More detail

Not so long ago I started to host my code to forgejo. There is a promise that in the future it will support federation and forgejo is the same project that is used for codeberg.

The only problem I had was one day, I discovered that my entire node was down. At first I didn't investigate and just restarted the node. But soon after a few hours, it was down again. Looking at the reason, clearly thousands of requests that looked at every commit which put too much pressure on the system. Who could be so interested in using the web API to look at every commit instead, of… you know, clone the repository locally and explore it. Quickly, yep, like so many of you, I discovered that tons of crawlers that did not respect the robots.txt are crawling my forgejo instance until death ensues.

So I had no choice, I first used a radical approach and blocked my website entirely except from me. But hey, why having a public forge if not for people to be able to look into it time to time?

I then installed Anubis, but it wasn't really for me. It is way too heavy for my needs, not as easy as I would have hoped to configure and install.

Then I saw this article You don't need anubis on lobste.rs using a simple configuration in caddy that should block these pesky crawlers. I made some adjustments to adapt it to nginx. For now, this is working perfectly well, my users are just redirected once, without really noticing it. And they could use forgejo as they could before. And this puts the crawlers away.

The strategy is pretty basic; in fact, a lot less advanced than the strategy adopted by Anubis. For every access of my website, I just check if the user has a specific cookie set. If not, I redirect the user to a 418 HTML page containing some js code to execute that set this specific cookie and reload the page.

That's it.

I also tried to return a 302 and add a cookie from the response without javascript, but the crawlers are immune to that second strategy. Unfortunately this means, my website could only be seen if you enable javascript in your browser. I feel this is acceptable. I guess, someday this very basic protection will not be enough and my forgejo instance will break again, and I will be forced to use more advanced system like Anubis or perhaps even iocaine.

I hope this could be helpful, because, I recently saw many discussions on that subject where people were not totally happy to use Anubis, while at least for me, this quick dirty fix does the trick. And I am fully aware that this would be very easy to bypass. But for now, I think the volume is more important than the quality for these crawlers and it may take a while for them to need to adapt. Also, by publishing this, I know if too many people use the same trick, quickly, these crawlers will adapt.

Julbord and Juliard

Liza Shulyayeva — Sat, 20 Dec 2025 23:01:33 GMT

Last week the team went to a beautiful Julbord at Fjäderholmarnas Krog on Fjäderholmarna, an island near Stockholm. Last year we had our Julbord on the same island, but at Restaurang Rökeriet. I guess we’re creatures of habit.

Reviewing A Tree Grows in Brooklyn by Betty Smith

Davis Haupt's Blog — Sat, 20 Dec 2025 19:00:00 GMT

A Tree Grows in Brooklyn is a quintessential coming of age story. Not just for Francie — the protagonist who we follow from the age of 10 through her going off to college — but also for New York itself, which we see change through industrialization along with the characters.

The first part (of five) is on the slower side, with barely-connected vignettes that paint a picture of what it was like to grow up in an immigrant community in Williamsburg around the turn of the century. These ensure that you really feel connected to Francie’s family and neighborhood by the time the proper story gets going in the second part.

I wonder why this wasn’t a part of my high school English curriculum: the book has a lot to say about everything from childhood and motherhood to the American Dream. I’m happy I picked it up, I enjoyed this more than I expected to!

After Ruining a Treasured Water Resource, Iran Is Drying Up (Fred Pearce, Yale E360)

Alexandre Storelli — Sat, 20 Dec 2025 13:04:47 GMT

More than international sanctions, more than its stifling theocracy, more than recent bombardment by Israel and the U.S. — Iran’s greatest current existential crisis is what hydrologists are calling its rapidly approaching “water bankruptcy.”

It is a crisis that has a sad origin, they

Reactivity in Angular

Stories by 🪄 OZ 🎩 on Medium — Sat, 20 Dec 2025 11:41:44 GMT

“The Great Wave off Kanagawa”, Katsushika Hokusai, 1831

This article explains why we should build our Angular apps with reactivity in mind and how immutability helps with it.

The Magic

Look at this example:

@Component({
  template: `
    <div>Name: {{user.name}}</div>
    <div>Age: {{user.age}}</div>

     <button (click)="updateName()">Set Random Name</button>
     <button (click)="updateAge()">Set Random Age</button>
  `,
})
export class App {
  user = {
    name: 'Alice',
    age: 25,
  }

  updateName() {
    const i = Math.floor(Math.random() * names.length);
    this.user.name = names[i];
  }

  updateAge() {
    this.user.age = Math.floor(Math.random() * 20 + 20);
  }
}

https://medium.com/media/feab2a931a3948782e5a270cf8ecb53c/href

It works, but it only works because of magic. Dark magic. I wish it didn’t work :) What’s much worse is that code like this is scattered across Angular tutorials for beginners, so it shouldn’t be surprising that many Angular apps have similar code, and that many readers right now are asking, “What the hell is wrong with this code, dude? It just works. Chill, man.”

What works

In our template, we have bindings:

<div>Name: {{user.name}}</div>
<div>Age: {{user.age}}</div>

When user.name changes, Angular reflects this change and updates the HTML element. That seems quite reasonable and logical.

But how does Angular know that user.name has changed? We didn’t call anything like heyAngularWeChangedTheUserObject() or even checkBindingsPlease(). This is where the dark magic hides — and this magic has its price.

What is the price

The magic tricks here are “dirty checking” and “monkey patching”.

They hurt performance and can cause data pollution (undesired mutations) in non-trivial apps. But they work just fine in small apps, especially in the simple examples provided in tutorials.

To cast the “dirty checking” spell, Angular has to check every binding (and every “input”) in every component of your application. Some of these components are used in “for” loops, some are reused multiple times, so the number of rendered components might be higher than the total number of components your app has.

And Angular doesn’t know when your bindings might change. So Angular reacts to every change of every [input] and (output) and DOM event listeners like (click). And still, it is not enough.

Data in your app might change asynchronously. Not right after the (output) has emitted (for example), but a little bit later, after loading some data, for example. And Angular will run its dirty checking too early to notice the changes.

For that, Angular uses another spell: “monkey patching.”

A special tool, Zone.js, wraps asynchronous APIs like setTimeout, requestAnimationFrame, Promise, MutationObserver, and events like click, change, mousemove, and many others [1]. So when they are called, Zone.js notifies Angular — and that’s how it knows when to cast the “dirty checking” spell.

Did you just say mousemove?

Yes. And scroll is also patched. Now you can imagine how many times Angular has to check every binding in your components.

The existence of this dark magic led to a special rule:

Thou shalt not call functions in your templates! ☝️

Even beginners know this rule, because it’s practically a commandment in many tutorials.

The reason: comparing two variables by reference is a very cheap operation in terms of performance. But if a binding involves a function, that function will be called, and computing its value might not be so cheap.

This rule is nothing but an adaptation to the shortcomings of the dark magic we just explored.

Is the OnPush Change Detection Strategy Enough?

There are two change detection strategies in Angular that components can use, and one of them, OnPush, instructs the framework to check not every component in the app, but only the modified component and its ancestors.

But just changing the strategy in an existing component is not enough. First, every binding should be reactive — otherwise, we’ll do more harm than good.

Let’s modify our example a bit:

@Component({
  changeDetection: ChangeDetectionStrategy.OnPush,
// ...

  updateAge() {
    // Any asynchronous code.
    // Imagine we are loading the allowed ages list.
    setTimeout(() => {
      this.user.age = Math.floor(Math.random() * 70 + 20);
    }, 1);
  }
}

https://medium.com/media/c3cceb126ef82614e51f1312c4e1f559/href

Now, if you click “Set Age” first, you will see no changes. But if you click “Set Name” afterwards, you’ll see both the name and the age updated.

Explanation of the bug:

When we click the button, the event handler not only calls updateAge(), but also marks our component as “dirty” and schedules a Change Detection cycle;
Change Detection runs, but can’t see any changes because they will be applied later (asynchronously). It removes the “dirty” mark from our component;
setTimeout() is patched by Zone.js, so after 1ms, it schedules a Change Detection cycle;
Change Detection runs, but our component has the OnPush strategy and is not marked as “dirty” (see step 2), so the component is skipped;
When we click another button, the event handler calls updateName(), marks our component as dirty, and schedules a Change Detection cycle;
Change Detection runs and sees changes in both of our bindings: user.name, which we just changed, and user.age, which we changed previously. Both changes are then reflected.

This is an example of why we should not use OnPush with non-reactive bindings.
We should only use OnPush when every binding in our template is reactive.

As you can see from the steps 3 and 4, Zone.js can notify the framework about when, but not where a change detection is required.

Angular is moving away from black magic. In the Zone.js repo, you can find [2]:

As Angular moves towards a zoneless application development model, Zone.js is no longer accepting new features, including additional patches for native platform APIs. The team will also not be accepting any low priority bug fixes. Any critical bug fixes that relate to Angular’s direct use of Zone.js will still be accepted.

And this is the direction we all should move as well — towards…

Pure Reactivity

If we notify the framework that some parts of our templates have changed, then the framework will not need all that dark magic and can:

Check only the modified parts;
Only when needed;
Optimize DOM updates even with asynchronous changes;
Stop using monkey patching.

It might sound too good to be true, but we can do this already — starting with Angular version 20! We’ll need 3 things:

bindings in our templates should use only Signals;
every component should use OnPush change detection strategy;
provideZonelessChangeDetection() in bootstrapApplication() providers.

If, for some reason, you can’t use Angular v20 yet, or some old libraries are not compatible with zoneless change detection — don’t worry. If you can use Signals for bindings (or at least the async pipe with Observables), and all your components use the OnPush change detection strategy, the performance of your app will be quite close to that of a zoneless app.

An additional benefit of a zoneless app: it forces your code not to rely on Zone.js and to be purely reactive.

Reactive bindings

The point of reactive bindings is to notify Angular about the changes (when and where they happened), so Angular can react (pun intended) and reflect the changes with minimal performance costs.

Let’s fix our bug by replacing our non-reactive bindings with reactive ones:

https://medium.com/media/b42ac25ae290e3115e028a746dc3f033/href

Let’s analyze our code:

@Component({
  selector: 'app-root',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <div>Name: {{name()}}</div>
    <div>Age: {{age()}}</div>
    ...
  `,
})
export class App {
  user = signal<User>({
    name: 'Alice',
    age: 25,
  });

  name = computed(() => this.user().name);
  age = computed(() => this.user().age);

  updateName() {
    const i = Math.floor(Math.random() * names.length);
    this.user.update((user) => ({
      ...user,
      name: names[i],
    }));
  }

  updateAge() {
    setTimeout(() => {
      this.user.update((user) => ({
        ...user,
        age: Math.floor(Math.random() * 70 + 20),
      }));
    }, 1);
  }
}

Now user is a signal, we have two derived (computed) signals: name and age, and our updateName() and updateAge() methods have been modified a little.

Every time we modify the user signal, it sends notifications to name and age, and they send notifications to the template.
When this happens, the template marks our component as “dirty” and schedules a Change Detection cycle.

Without any magic, we let Angular know where and when changes happened, so Angular can granularly update only the needed parts — and only when it’s needed.

But wait, we are calling functions in our template! 😱

Yes, and it’s ok. Signals are functions, but their call is super cheap because they don’t compute their value on every call. They memoize their value, so calling them doesn’t hurt performance.
In fact, any function that memoizes its value can be safely called from the template [3]. Signals just guarantee this out of the box.

Immutability

In the updateName() and updateAge() methods, we use the update() method of an Angular Signal and create a shallow copy of the existing object. Why not just mutate the fields of the existing object?

Because when we update an Angular Signal using set() or update(), Angular compares the new value with the old one. A notification will be sent only if they are not equal. And they are compared by reference (===).

Two references to the same object are always considered equal — and that’s why we create a shallow copy: to trigger the value change notification.

You can verify this behavior in the following new methods:

mutateAge() {
  const user = this.user();
  user.age = Math.floor(Math.random() * 70 + 20);
}

mutateAgeAndSet() {
  const user = this.user();
  user.age = Math.floor(Math.random() * 70 + 20);
  this.user.set(user);
}

In mutateAge(), we mutate the field of a signal value. As you can check, this will not work.

In mutateAgeAndSet(), we mutate the field and call the signal’s set() method. It will compare two user objects, they are equal by reference, so this will not trigger any changes either.

You can read more about Angular Signals reactivity and mutations in my other article [4].

There is an easy trick to protect ourselves from this mistake:

export type User = {
  readonly name: string;
  readonly age: number;
};

There are more advanced tools to provide immutability, but this one doesn’t require any libraries to use.

Immutability is not only helpful for reactivity. It has other benefits: your data will not be polluted (modified by code that has no clue it’s modifying shared data), it protects from unexpected side effects, and it makes testing easier.

It is possible to override the default equality check function in Angular Signals (in most of their kinds), but you should only do this in exceptional cases, when providing the new values in an immutable way is more expensive than checking equality manually.
Checking equality in nested objects recursively can be quite expensive in terms of performance and might require special handling if the objects have circular references.

Performance

Let’s explore why the Signals in Templates + OnPush + Zoneless formula provides the best possible performance for your Angular app.

A template is a consumer of signals and behaves similarly to effect(), but it also schedules a Change Detection cycle when a signal is updated.

Unlike the async pipe [9], the template will not be triggered on every update of the signal. As we learned above, only non-equal values will trigger an update.
Also, if a signal is updated 100 times synchronously (each time with a new value), the template will schedule just one Change Detection cycle.

Here is the difference in how Observables and Signals deliver their update notifications:

Observables emit every time we ask them to. They don’t check if the next value is equal to the previous one.
When an Observable emits a value, the subscriber must handle it, because it can’t predict whether there will be another.
We could use debounceTime(0), but that would introduce unnecessary asynchrony when a synchronous update would be sufficient;
Consumers of signals receive only a notification about the update, not the new value. To get the new value, they must read the updated signal — and they are free to do this whenever they want. In the case of computed signals, this means that the new value will be recomputed not at the moment when the signals used in the computation are updated, but when the consumer reads the value of that computed signal. This can eliminate a lot of unnecessary computations, because consumers (effect(), templates) schedule the reads of the signals they are subscribed to, so they don’t read more often than needed. You can read more about signals timings in the article linked below [6].

When the OnPush strategy is combined with signals (your template uses only signals for reactivity and all components use the OnPush strategy), Angular applies an optimization called “Local Change Detection” [5]. It doesn’t mark every ancestor as “dirty”; instead, it marks only the component as “dirty” and marks each ancestor “for traversal.”
This means that non-dirty ancestors will not be checked.

And when every binding (that can change) in our templates uses a signal, we simply don’t need Zone.js and its performance overhead — Angular already knows where and when changes happened.

Combined with the “Single Source of Truth” and “Template First” approaches ([7], [8]), this article will help you create super-performant, declarative, and scalable code. To the stars! 🚀

Buy Me a Coffee ☕️

⌘← and ⌘→ hotkey navigation in Claude Code and Codex

Rob — Sat, 20 Dec 2025 09:15:20 GMT

You can make ⌘+Left and ⌘+Right hotkeys navigate Claude Code and Codex terminal input to start and end of lines. This post focuses on iTerm2 for macOS but this should work in virtually any terminal supporting keybindings. iTerm2 → Preferences → Profiles → Key Bindings For ⌘+Right: Command Up and Down ⌘↑ and ⌘↓ are… Continue reading

agent-shell 0.25 updates

xenodium.com @alvaro — Sat, 20 Dec 2025 02:00:00 GMT

It's been a little while since the last agent-shell blog post detailing changes, so we're naturally due another one detailing the latest features.

What's `agent-shell`?

A native Emacs shell to interact with any LLM agent powered by ACP (Agent Client Protocol).

✨ Sponsor agent-shell ✨

So what's new?

Let's go through the latest changes…

Viewport/compose (experimental)

The biggest change is the new experimental viewport/compose mode. While agent-shell's comint shell experience has its benefits, some folks may opt for a more familiar buffer experience, that is less shell-like.

There are perhaps 3 defining characteristics in the new viewport/compose feature:

A dedicated compose buffer: You get a full, multiline buffer dedicated to crafting prompts. I personally find this mode of operation more natural (no need to watch out for accidental submissions via RET), but also opens up the possibility to enable your favourite minor modes that may not play nice with comint. You can launch compose buffers via M-x agent-shell-prompt-compose, edit your prompt, and when you're ready, submit with the familiar C-c C-c binding.

Viewport: I've experimented with shell viewports before and also added a similar experience to chatgpt-shell. This compose/viewport UX quickly became my primary way of interacting with non-agent LLMs. This is a read-only buffer typically displaying the latest agent interaction. Use n/p to navigate through current interaction items. Use f/b to switch through pages/interactions.

Auto-modal: Compose and viewport modes complement each other and offer automatic transition between read-only and editable (compose) buffers. From a viewport, you can always press r to reply to the latest interaction. When replying, you automatically go into edit/compose mode. When submitting via C-c C-c, you automatically transition into viewport (read-only) mode.

While you can use M-x agent-shell-prompt-compose at any time to compose multi-line prompts and send from the shell, to get the compose/viewport hybrid experience, you need to enable with (setq agent-shell-prefer-viewport-interaction t). From then on, M-x agent-shell will favor the compose/viewport experience. You can always jump between viewport and shell with C-c C-o.

Prompt queueing (experimental)

agent-shell buffers now offer the ability to queue additional prompts if the agent is busy. Use M-x agent-shell-queue-request and M-x agent-shell-remove-pending-request to queue and remove requests.

Session model/mode

You can now change models via M-x agent-shell-set-session-model (C-c C-v), when supported by the agent.

For Anthropic users, we now have agent-shell-anthropic-default-model-id and agent-shell-anthropic-default-session-mode-id to set default agent model and modes. You can view available values by expanding shell handshake items.

If keen on using defaults for a different agent, please file a feature request.

Set preferred agent

By default, launching via M-x agent-shell prompts users to select one of the supported agents. You can now skip this by setting your preferred agent (thank you Jonathan).

(setq agent-shell-new-shell-config (agent-shell-anthropic-make-claude-code-config))

Automatic transcripts

While shell-maker automatically prompts users to save content when killing agent-shell buffers, its integration was a little clunky with agents. Elle Najt's agent-shell-specific implementation is now enable by default, saving Markdown transcripts to project/.agent-shell/transcripts. When launching new shells, you should see a message like:

Created project/.agent-shell/transcripts/2025-12-17-22-07-38.md

You can always open the current transcript via M-x agent-shell-open-transcript.

To disable the new transcript generation use:

(setq agent-shell-transcript-file-path-function nil)

MCP servers

Jonathan Jin introduced agent-shell-mcp-servers, enabling folks to add MCP servers to their agents.

For example:

(setq agent-shell-mcp-servers
      '(((name . "notion")
         (type . "http")
         (headers . [])
         (url . "https://mcp.notion.com/mcp"))))

Buffer search

You can now search across shell nodes, including collapsed ones. When using isearch (swiper too), matching nodes are now automatically expanded.

DWIM context

When invoking M-x agent-shell, active region, flymake errors, dired and image buffers are now automatically considered and brought over to agent-shell buffers to be included while crafting prompts.

There's one more. From a viewport buffer, selecting a region and pressing "r" (for reply) brings the selection over to the compose buffer as blockquoted text.

Cursor support (migrated to Mike Moore's adapter)

We've migrated Cursor agent support to use Mike Moore's ACP Adapter.

Install with:

npm install -g @blowmage/cursor-agent-acp

New related packages

Paul Nelson built agent-shell-attention.el offering a mode line attention indicator.
Julian Hirn built agent-review introducing a streamlined workflow.

Bug fixes

#106: Use replace-buffer-contents instead of erase-buffer/insert
#127: No longer possible to select the Anthropic model used by Claude Code
#142: [bug] Crash during message streaming: markdown overlay receives nil positions
#143: gemini 0.17.1 requires authMethod to authenticate (fix by Andrea)
#144: Make collapsible indicator keymap customizable
#145: Unable to enter Plan Mode until after first message is sent
#150: Warning (undo): Buffer 'Codex Agent @ …' undo info was 25664948 bytes long
#154: Gemini CLI doesn't need authorization if already logged in

Pull requests

Thank you to all contributors for these improvements!

#125: Fix error when viewing proposed diffs (Nat Page)
#129: Support setting a preferred agent config (Jonathan Jin)
#138: Enable specifying MCP server configurations via custom variable (Jonathan Jin)
#139: Document MCP server config functionality (Jonathan Jin)
#140: README: Add MELPA badge + expand install instructions (Jonathan Jin)
#141: Add keybindings to cycle/set session mode (Jonathan Jin)
#149: Use fixed-pitch for ascii art logos (Mark A. Hershberger)
#155: Give the new custom flag to gemini for skipping the authorization (ccQpein)

Lots of other work ❤️😅

Beyond what's showcased, much love and effort's been poured into polishing the agent-shell experience. Interested in the nitty-gritty? Have a look through the 122 commits since the last blog post.

Make the work sustainable

If agent-shell or acp.el are useful to you, please consider sponsoring development. LLM tokens aren't free, and neither is the time dedicated to building this stuff ;-)

🎄 Advent of EIP Day 3: Message Channels

James Carr — Sat, 20 Dec 2025 02:00:00 GMT

Welcome back to the Advent of Enterprise Integration Patterns! In Day 2, we introduced Message Endpoints and the Messaging Gateway pattern to decouple our application from the transport layer, plus Pipes and Filters for composable event processing. We ended with a bit of a cliffhanger: running producers and consumers as separate processes worked great for distribution, but left us with fragmented data across isolated ETS stores. Today we’re going to tackle that problem head-on—and then explore the different types of message channels available to us.

Werner Vogels is right

Look mum, I have a blog on tsak.dev — Sat, 20 Dec 2025 02:00:00 GMT

Late November Changelog published an interview with Werner Vogels. Until that point I was unaware that he is the CTO of Amazon, and I ended up really liking his take on things. One thing that stood out to me specifically was his level-headed stance on the current AI hype. Around the 1:22:20 mark he says:

[…] there isn’t almost a CIO that I meet today when I’m travelling that asks me, […] what should I be doing with AI? And I go like, well, my excuses is [it is] very inappropriate to answer a question with a question “but why are you asking me this?” and just yeah but those guys next door you know they will be ahead of us or and I say are you really certain of that and then maybe because you’re a little bit older you know you start to drive down into what is actually the problem they’re trying to solve with this technology and is this the right technology for this every week we see five new models or 10 new models suddenly we went from regular LLMs to reasoning LLMs. I think as a business there is no shame in […] hitting the pause button for a moment and say, why don’t we get ourselves educated about all of this? […] and not just us as technologists, but also the business. […]

AI, Structural Change, and the Future of Work (seminar notes)

Liza Shulyayeva — Fri, 19 Dec 2025 23:01:33 GMT

Yesterday morning I went to a breakfast seminar about AI and the future of work at Segerstedthuset. It ended up being a great discussion that went off the rails of the original ‘plan’ in a way that felt interesting and productive. My hasty notes are below.

Presenting the Case That the Future Will Be Unrecognizable

Second Thoughts — Fri, 19 Dec 2025 19:19:20 GMT

We should prepare for the possibility of profound change

Help my website is too small

Luke Plant's home page — Fri, 19 Dec 2025 15:45:33 GMT

How can it be a real website if it’s less than 7k?

DNS over HTTPS on Ubuntu

Swag Industries — Fri, 19 Dec 2025 10:28:21 GMT

edit April 2026: works on Ubuntu 26.04, because systemd-resolved still does not support DoH.

Enhance your privacy and protect yourself from your ISP. Hide your DNS requests behind a random HTTPS connection. This guide will work on Ubuntu 26.04 (and 24.04 and so on). This guide also

Rosie’s a shop dog, Samson’s an office dog

Notes from the Burrow — Fri, 19 Dec 2025 09:56:47 GMT

I love how my dogs have very different personalities. Rosie is a goofball that loves everyone and thinks every dog and human is a friend. Samson is a bit more...

A Brief History of Roombas with Fart Spray

taylor.town — Fri, 19 Dec 2025 02:00:00 GMT

A true tale of robot vacuum innovation

How do git remotes work? And how do I self-host my own?

Charles Féval — Fri, 19 Dec 2025 02:00:00 GMT

What it takes to create the simplest, barest self-hosted git remote, and learn stuff about git in the process.

For Strong Structured Concurrency

vito.nyc — Thu, 18 Dec 2025 16:00:00 GMT

Let us consider for a moment the construction of an operation in C++26’s std::execution (hereafter exec).¹ In such a construction we need several things: we need a sender, the source of an operation; and a receiver, the sink of an operation. We combine them with exec::connect(sender, receiver) to form an operation state (op_state).

The resulting object captures the idea of work, but does not induce work by construction. Work begins only when we enter an operation state with exec::start(op_state). For simple programs² the tree-shaped³ collection of operation states is fixed by composition.⁴ The density of footnotes in the previous sentence is sufficient evidence that we ought not linger here, for fear of foundering amongst them.

How PyTorch Generates Random Numbers in Parallel on the GPU

Confessions of a Code Addict — Thu, 18 Dec 2025 12:26:29 GMT

A deep dive into Philox and counter-based RNGs

Less

Nicola Iarocci — Thu, 18 Dec 2025 09:50:22 GMT

When I’m writing, I write. When I’m cooking, I cook. When I’m talking to someone, I put my phone away. The constant mental juggling that felt necessary before now feels exhausting. There’s something meditative about giving your full attention to a single task.

– 47nil

The Revolution Will Not Make the Hacker News Front Page

Dhole Moments — Thu, 18 Dec 2025 03:51:31 GMT

(with apologies to Gil Scott-Heron) If you get all of your important technology news from “content aggregators” like Hacker News, Lobste.rs, and most subreddits, you might be totally unaware of the important but boring infrastructure work happening largely on the Fediverse, indie web, and other less-centralized communities. This is no accident. The rough consensus of […]

Do Newer Models Hold Up as Context Fills?

Tiberriver256 — Thu, 18 Dec 2025 02:00:00 GMT

My experience has always been that AI models get pretty dumb after about 50% of their context window is filled. @vikhyatk on x.com challenged my assumption and said it’s been getting better. I decided to put on a little test. The below experiment was fully conducted and documented by gpt-5.2-codex and the codex CLI. We used the copilot cli for the sonnet 4.5 part of the experiment.

Experiment setup

Models: gpt-5.1-codex-max, gpt-5.2-codex, claude-sonnet-4.5
Tasks:
- Recall: three facts inserted around ~10k tokens into the prompt
- SVG: output a single SVG of a pelican riding a bicycle
Context fill levels: 0%, 25%, 50%, 75%, 98%
Runs: one run per task per context fill
Filler: deterministic structured text so the prompt reaches the target token count
Tooling: uv run context_window_experiment.py
CLI runners: Codex CLI (default) and Copilot CLI via --runner copilot --models claude-sonnet-4.5

If you want to reproduce the results, save the script below as context_window_experiment.py and run uv run context_window_experiment.py.

Experiment script (uv run)

# /// script
# dependencies = ["tiktoken>=0.7.0"]
# ///
"""Run context window performance experiments using the Codex or Copilot CLI.

Usage:
  uv run context_window_experiment.py
  uv run context_window_experiment.py --runner copilot --models claude-sonnet-4.5
"""

from __future__ import annotations

import argparse
import datetime as dt
import hashlib
import json
import pathlib
import random
import subprocess
import time
from dataclasses import dataclass
from typing import List, Optional, Tuple

import tiktoken

DEFAULT_MODELS = ["gpt-5.1-codex-max", "gpt-5.2-codex"]
DEFAULT_CONTEXT_PCTS = [0, 25, 50, 75, 98]
DEFAULT_RUNS = 1
DEFAULT_FACT_OFFSET_TOKENS = 10_000
DEFAULT_CONTEXT_WINDOW = 200_000
DEFAULT_ENCODING = "o200k_base"
DEFAULT_RUNNER = "codex"
DEFAULT_OUTPUT_DIR = "context-window-results"

FACTS = [
    "The pelican's name is Harbor.",
    "The bicycle is painted teal with a white bell.",
    "The experiment code word is WINTER-ALPHA-7.",
]

TASK_PELICAN = "pelican_code"
TASK_RECALL = "fact_recall"

PELICAN_INSTRUCTIONS = (
    "TASK: Output a single SVG of a pelican riding a bicycle.\n"
    "Requirements:\n"
    "- Output SVG only, no Markdown, no code fences.\n"
    "- Keep the SVG within a 400x300 viewBox.\n"
    "- Use simple shapes and paths; no external assets.\n"
)

RECALL_INSTRUCTIONS = (
    "TASK: List the three facts exactly as stated in the IMPORTANT FACTS block.\n"
    "Return them as three bullet points, nothing else.\n"
)

INTRO_TEXT = (
    "You are participating in a context window experiment.\n"
    "Ignore filler text. Only follow the TASK at the end.\n"
    "Filler text begins below.\n"
)

FILLER_HEADER = "BEGIN FILLER\n"
FILLER_FOOTER = "END FILLER\n"

FACTS_HEADER = "IMPORTANT FACTS (memorize for later):\n"
FACTS_FOOTER = "END FACTS\n"

WORD_BANK = [
    "alpha",
    "bravo",
    "charlie",
    "delta",
    "echo",
    "foxtrot",
    "golf",
    "hotel",
    "india",
    "juliet",
    "kilo",
    "lima",
    "mike",
    "november",
    "oscar",
    "papa",
    "quebec",
    "romeo",
    "sierra",
    "tango",
    "uniform",
    "victor",
    "whiskey",
    "xray",
    "yankee",
    "zulu",
    "amber",
    "basil",
    "cedar",
    "dune",
    "ember",
    "fjord",
    "grove",
    "harbor",
    "ivory",
    "jade",
    "kelp",
    "linen",
    "moss",
    "nova",
    "onyx",
    "pearl",
    "quartz",
    "reef",
    "stone",
    "tulip",
    "umber",
    "velvet",
    "willow",
    "xenon",
    "yellow",
    "zephyr",
]


@dataclass
class PromptParts:
    prompt: str
    total_tokens: int
    filler_before_tokens: int
    filler_after_tokens: int
    facts_start_tokens: Optional[int]
    target_total_tokens: int


class TokenCounter:
    def __init__(self, encoding_name: str) -> None:
        self.encoding_name = encoding_name
        self.encoding = tiktoken.get_encoding(encoding_name)

    def count(self, text: str) -> int:
        return len(self.encoding.encode(text))


def parse_model_contexts(raw_pairs: List[str]) -> dict:
    model_contexts: dict = {}
    for item in raw_pairs:
        if "=" not in item:
            raise ValueError(f"Invalid model context override: {item}")
        model, window = item.split("=", 1)
        model = model.strip()
        window_value = int(window.strip())
        model_contexts[model] = window_value
    return model_contexts


def stable_seed(*parts: str) -> int:
    payload = "|".join(parts).encode("utf-8")
    digest = hashlib.sha256(payload).digest()
    return int.from_bytes(digest[:8], "big")


def make_sentence(rng: random.Random, index: int) -> str:
    words = rng.sample(WORD_BANK, 12)
    return f"FILLER {index:05d}: " + " ".join(words) + ".\n"


def build_block(rng: random.Random, sentences: int = 25) -> str:
    return "".join(make_sentence(rng, i + 1) for i in range(sentences))


def build_filler(
    target_tokens: int, counter: TokenCounter, seed_label: str
) -> Tuple[str, int]:
    if target_tokens <= 0:
        return "", 0

    rng = random.Random(stable_seed(seed_label))
    block = build_block(rng)
    block_tokens = counter.count(block)

    parts: List[str] = []
    total_tokens = 0
    index_offset = 0

    if block_tokens > 0:
        while total_tokens + block_tokens <= target_tokens:
            parts.append(block)
            total_tokens += block_tokens
            index_offset += 25

    # Build remainder with fresh sentences to avoid repeating the same block too much.
    remainder_rng = random.Random(stable_seed(seed_label, "remainder"))
    sentence_index = index_offset + 1
    while total_tokens < target_tokens:
        sentence = make_sentence(remainder_rng, sentence_index)
        sentence_tokens = counter.count(sentence)
        if total_tokens + sentence_tokens > target_tokens:
            break
        parts.append(sentence)
        total_tokens += sentence_tokens
        sentence_index += 1

    padding_unit = " filler"
    padding_tokens = counter.count(padding_unit)
    while total_tokens + padding_tokens <= target_tokens:
        parts.append(padding_unit)
        total_tokens += padding_tokens

    parts.append("\n")
    return "".join(parts), total_tokens


def build_facts_block() -> str:
    lines = [FACTS_HEADER]
    for fact in FACTS:
        lines.append(f"- {fact}\n")
    lines.append(FACTS_FOOTER)
    return "".join(lines)


def build_prompt(
    *,
    task: str,
    target_total_tokens: int,
    counter: TokenCounter,
    fact_offset_tokens: int,
    seed_label: str,
) -> PromptParts:
    if task == TASK_PELICAN:
        task_instructions = PELICAN_INSTRUCTIONS
        include_facts = False
    elif task == TASK_RECALL:
        task_instructions = RECALL_INSTRUCTIONS
        include_facts = True
    else:
        raise ValueError(f"Unknown task: {task}")

    intro = INTRO_TEXT + FILLER_HEADER
    intro_tokens = counter.count(intro)

    facts_block = build_facts_block() if include_facts else ""
    facts_tokens = counter.count(facts_block)

    task_tokens = counter.count(task_instructions)
    footer_tokens = counter.count(FILLER_FOOTER)

    if include_facts:
        filler_before_target = max(0, fact_offset_tokens - intro_tokens)
        filler_before, filler_before_tokens = build_filler(
            filler_before_target, counter, f"{seed_label}|before"
        )
        facts_start_tokens = intro_tokens + filler_before_tokens
    else:
        filler_before = ""
        filler_before_tokens = 0
        facts_start_tokens = None

    fixed_tokens = (
        intro_tokens
        + filler_before_tokens
        + facts_tokens
        + footer_tokens
        + task_tokens
    )

    filler_after_target = max(0, target_total_tokens - fixed_tokens)
    filler_after, filler_after_tokens = build_filler(
        filler_after_target, counter, f"{seed_label}|after"
    )

    prompt = "".join(
        [
            intro,
            filler_before,
            facts_block,
            filler_after,
            FILLER_FOOTER,
            task_instructions,
        ]
    )

    total_tokens = counter.count(prompt)

    return PromptParts(
        prompt=prompt,
        total_tokens=total_tokens,
        filler_before_tokens=filler_before_tokens,
        filler_after_tokens=filler_after_tokens,
        facts_start_tokens=facts_start_tokens,
        target_total_tokens=target_total_tokens,
    )


def run_cli(
    *,
    runner: str,
    prompt: str,
    prompt_path: pathlib.Path,
    model: str,
    output_path: pathlib.Path,
    log_path: pathlib.Path,
) -> Tuple[int, float]:
    if runner == "codex":
        cmd = [
            "codex",
            "exec",
            "-m",
            model,
            "--color",
            "never",
            "--output-last-message",
            str(output_path),
        ]

        start = time.time()
        with log_path.open("w", encoding="utf-8") as log_file:
            proc = subprocess.run(
                cmd,
                input=prompt,
                text=True,
                stdout=log_file,
                stderr=log_file,
                check=False,
            )
        end = time.time()
        return proc.returncode, end - start

    if runner == "copilot":
        cmd = [
            "copilot",
            "--model",
            model,
            "--no-color",
            "--stream",
            "off",
            "--silent",
            "--add-dir",
            str(prompt_path.parent),
            "--prompt",
            f"@{prompt_path}",
        ]

        start = time.time()
        with output_path.open("w", encoding="utf-8") as output_file, log_path.open(
            "w", encoding="utf-8"
        ) as log_file:
            proc = subprocess.run(
                cmd,
                text=True,
                stdout=output_file,
                stderr=log_file,
                check=False,
            )
        end = time.time()
        return proc.returncode, end - start

    raise ValueError(f"Unknown runner: {runner}")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Run context window experiments with Codex or Copilot CLI."
    )
    parser.add_argument(
        "--runner",
        choices=["codex", "copilot"],
        default=DEFAULT_RUNNER,
        help="CLI runner to use.",
    )
    parser.add_argument(
        "--models",
        default=",".join(DEFAULT_MODELS),
        help="Comma-separated model list.",
    )
    parser.add_argument(
        "--context-percentages",
        default=",".join(str(pct) for pct in DEFAULT_CONTEXT_PCTS),
        help="Comma-separated target context percentages.",
    )
    parser.add_argument(
        "--runs",
        type=int,
        default=DEFAULT_RUNS,
        help="Number of repetitions per task and context percentage.",
    )
    parser.add_argument(
        "--context-window",
        type=int,
        default=DEFAULT_CONTEXT_WINDOW,
        help="Context window size in tokens (default applies to all models).",
    )
    parser.add_argument(
        "--model-context",
        action="append",
        default=[],
        help="Override context window for a model (format: model=window).",
    )
    parser.add_argument(
        "--encoding",
        default=DEFAULT_ENCODING,
        help="Tokenizer encoding name for tiktoken.",
    )
    parser.add_argument(
        "--fact-offset-tokens",
        type=int,
        default=DEFAULT_FACT_OFFSET_TOKENS,
        help="Place facts around this token offset for recall tests.",
    )
    parser.add_argument(
        "--seed",
        default="context-window-experiment",
        help="Base seed label for deterministic filler generation.",
    )
    parser.add_argument(
        "--output-dir",
        default=DEFAULT_OUTPUT_DIR,
        help="Base output directory for prompts and responses.",
    )
    parser.add_argument(
        "--run-id",
        default=None,
        help="Optional run id; defaults to timestamp.",
    )
    parser.add_argument(
        "--dry-run",
        action="store_true",
        help="Only generate prompts and metadata; do not call the CLI.",
    )
    parser.add_argument(
        "--skip-existing",
        action="store_true",
        help="Skip runs where output files already exist.",
    )
    return parser.parse_args()


def ensure_dir(path: pathlib.Path) -> None:
    path.mkdir(parents=True, exist_ok=True)


def main() -> int:
    args = parse_args()

    models = [item.strip() for item in args.models.split(",") if item.strip()]
    percentages = [
        int(item.strip())
        for item in args.context_percentages.split(",")
        if item.strip()
    ]

    model_contexts = {model: args.context_window for model in models}
    if args.model_context:
        model_contexts.update(parse_model_contexts(args.model_context))

    run_id = args.run_id
    if not run_id:
        run_id = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%dT%H%M%SZ")

    base_dir = pathlib.Path(args.output_dir) / run_id
    ensure_dir(base_dir)

    counter = TokenCounter(args.encoding)

    results_path = base_dir / "results.jsonl"

    tasks = [TASK_PELICAN, TASK_RECALL]

    for model in models:
        context_window = model_contexts.get(model, args.context_window)
        for pct in percentages:
            target_total = int(context_window * (pct / 100.0))
            for task in tasks:
                seed_label = f"{args.seed}|{task}|{pct}"
                prompt_parts = build_prompt(
                    task=task,
                    target_total_tokens=target_total,
                    counter=counter,
                    fact_offset_tokens=args.fact_offset_tokens,
                    seed_label=seed_label,
                )

                for run_index in range(1, args.runs + 1):
                    run_name = f"{model}__{pct}pct__{task}__run{run_index}"
                    run_dir = base_dir / run_name
                    ensure_dir(run_dir)

                    prompt_path = run_dir / "prompt.txt"
                    output_path = run_dir / "response.txt"
                    log_path = run_dir / "cli.log"
                    meta_path = run_dir / "meta.json"

                    if args.skip_existing and output_path.exists():
                        continue

                    prompt_path.write_text(prompt_parts.prompt, encoding="utf-8")

                    exit_code = None
                    elapsed = None
                    if not args.dry_run:
                        exit_code, elapsed = run_cli(
                            runner=args.runner,
                            prompt=prompt_parts.prompt,
                            prompt_path=prompt_path,
                            model=model,
                            output_path=output_path,
                            log_path=log_path,
                        )

                    actual_pct = (
                        prompt_parts.total_tokens / context_window
                        if context_window > 0
                        else None
                    )

                    meta = {
                        "run_name": run_name,
                        "runner": args.runner,
                        "model": model,
                        "context_window": context_window,
                        "target_context_pct": pct,
                        "target_total_tokens": prompt_parts.target_total_tokens,
                        "actual_total_tokens": prompt_parts.total_tokens,
                        "actual_context_pct": actual_pct,
                        "task": task,
                        "runs": args.runs,
                        "run_index": run_index,
                        "facts": FACTS if task == TASK_RECALL else [],
                        "facts_start_tokens": prompt_parts.facts_start_tokens,
                        "fact_offset_tokens": args.fact_offset_tokens,
                        "filler_before_tokens": prompt_parts.filler_before_tokens,
                        "filler_after_tokens": prompt_parts.filler_after_tokens,
                        "encoding": args.encoding,
                        "prompt_path": str(prompt_path),
                        "response_path": str(output_path),
                        "log_path": str(log_path),
                        "exit_code": exit_code,
                        "elapsed_seconds": elapsed,
                        "timestamp_utc": dt.datetime.now(dt.timezone.utc).isoformat(),
                    }

                    meta_path.write_text(json.dumps(meta, indent=2), encoding="utf-8")
                    with results_path.open("a", encoding="utf-8") as results_file:
                        results_file.write(json.dumps(meta) + "\n")

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Recall results

Exact means bullet-only output with no extra commentary.

Context %	gpt-5.1-codex-max	gpt-5.2-codex	claude-sonnet-4.5
0	Exact	Exact	Facts correct, extra text
25	Exact	Exact	Facts correct, extra text
50	Exact	Exact	Facts correct, extra text
75	Exact	Exact	Facts correct, extra text
98	Exact	Exact	Facts correct, extra text

Copilot responses included additional commentary and formatting beyond the requested bullet-only output.

SVG results

Below are the SVG outputs for each model at each context fill level. The response files were renamed and moved into images/context-window-performance-dropoff/ for rendering.

gpt-5.1-codex-max

0% context:

25% context:

50% context:

75% context:

98% context:

gpt-5.2-codex

0% context:

25% context:

50% context:

75% context:

98% context:

claude-sonnet-4.5 (Copilot CLI)

0% context:

25% context:

50% context: No SVG output (response asked for file access)

75% context:

98% context:

Takeaway

This is totally unscientific… but pretty much blows my idea out of the water. The funny part is that I think some of the svgs actually improve as the context window gets filled up which is… bizarre and kind of funny lol.

Hope you enjoyed the read!

Do Newer Models Hold Up as Context Fills? was originally published by Micah Rairdon at Tiberriver256 on December 18, 2025.

The 5 ECS Decisions That Waste 6 Weeks (And What to Pick Instead)

Thu, 18 Dec 2025 02:00:00 GMT

I’ve been helping Python teams deploy to AWS for the past 2 years now. The pattern is always the same: a team has a working FastAPI or Django app running perfectly on their laptops with docker-compose up, and then someone says “let’s put this in ECS.” Six weeks later, they’re still arguing about whether to use Fargate or EC2.

The problem isn’t that ECS is hard. The problem is that teams treat infrastructure decisions like they’re permanent. They’re not.

Last year I worked with a startup that spent 5 weeks evaluating container orchestration options. Five weeks. They had a working app. They had paying customers waiting. But the engineering team was stuck in an endless loop of “what if we need to scale?” and “shouldn’t we future-proof this?”

They launched on Fargate. It took 3 days once they stopped debating.

Here are the 5 decisions that waste the most time and what I tell every client to pick.

Fargate vs EC2: Just Use Fargate

This one wastes more time than all the others combined.

I get it. EC2 looks cheaper on paper. You can run the numbers, build a spreadsheet, show that at 50 containers you’ll save $400/month with EC2. The finance person gets excited. Someone mentions spot instances. Now you’re three meetings deep into capacity planning for traffic you don’t have yet.

Here’s what actually happens with EC2: you spend a week figuring out instance types, another week on auto-scaling groups, then you hit some weird issue where your containers won’t place because the bin-packing algorithm can’t find space, and suddenly your “cheaper” option has eaten two sprints of engineering time.

Fargate just works. You tell it how much CPU and memory you need, and it runs your container. No instances to manage, no patching, no capacity planning.

“But it’s more expensive!”

Sure. Maybe 20-30% more at scale. But you’re not at scale. You’re trying to ship. And even if Fargate costs you an extra $200/month right now, that’s nothing compared to the $30k+ in engineering salaries you’re burning while debating this.

Python apps especially benefit from Fargate. Your Django app with Celery workers is memory-heavy and I/O bound. You’re not doing CPU-intensive work. Fargate lets you right-size memory without playing Tetris with EC2 instance types.

Pick Fargate. When you’re running 200 containers 24/7 and have real cost data, revisit. Until then, move on.

ECS Service Discovery: Use an Internal ALB

When your services need to talk to each other, AWS gives you three options: Cloud Map, internal ALB, or Service Connect. I’ve seen teams spend weeks evaluating all three, setting up proof-of-concepts, reading whitepapers.

Just use an internal ALB.

I know, it’s not great. It’s a load balancer. It’s been around forever. But that’s exactly why you should use it:

It gives you a stable DNS name your services can call
Health checks work out of the box
You get access logs for debugging
Every developer on your team already understands HTTP

Your FastAPI service calls http://api-internal.yourdomain.local/users and it just works. No service mesh. No Envoy sidecars. No DNS caching gotchas.

Cloud Map is fine, but I’ve debugged too many issues where services couldn’t find each other because of DNS TTL problems. Service Connect is powerful, but now you’re operating a service mesh. Do you really want to be debugging Envoy proxy configuration when your actual problem is a database query?

The internal ALB is boring. Boring is good. Boring means you’re debugging your application code instead of your infrastructure.

CI/CD for ECS: Use GitHub Actions

I’m gonna be honest here: if your code is on GitHub, use GitHub Actions. Don’t overthink this.

“But CodePipeline is AWS-native!”

Yes, and it requires you to set up a pipeline with Source, Build, and Deploy stages, configure IAM roles for each stage, create buildspec files, and wire everything together. It’s more YAML for the same result.

“But Jenkins gives us more control!”

It’s 2025. Please don’t set up a Jenkins server. You’ll spend more time maintaining Jenkins than deploying your app.

GitHub Actions has an official AWS action that handles ECS deployments:

- name: Deploy to ECS
  uses: aws-actions/amazon-ecs-deploy-task-definition@v1
  with:
    task-definition: task-definition.json
    service: my-service
    cluster: my-cluster
    wait-for-service-stability: true

That’s the whole thing. It registers your task definition, updates the service, and waits for the deployment to stabilize. AWS maintains it. It works.

Your deployment workflow lives in your repo, your team already knows GitHub Actions from running tests, and you’re not managing another piece of infrastructure. If you want to understand how these pipeline runners actually work internally, I wrote a deep dive on building a CI/CD pipeline runner from scratch in Python.

If you’re on GitLab, use GitLab CI. If you’re on Bitbucket, use Bitbucket Pipelines. The point is: use whatever’s already integrated with your code. Don’t add complexity.

ECS Secrets Management: Use SSM Parameter Store

Where do you store your database passwords and API keys?

Not in your task definition. I’ve seen that. Please don’t.

The two real options are SSM Parameter Store and Secrets Manager. Teams debate this endlessly because Secrets Manager has automatic rotation and sounds more “enterprise.”

Here’s the thing: SSM Parameter Store is free, integrates natively with ECS, and handles 99% of use cases.

{
  "secrets": [
    {
      "name": "DATABASE_URL",
      "valueFrom": "arn:aws:ssm:us-east-1:123456789:parameter/myapp/database_url"
    }
  ]
}

Your Python app reads os.environ['DATABASE_URL'] like it does locally. No SDK, no code changes.

Secrets Manager costs $0.40 per secret per month and is worth it if you need automatic rotation for RDS credentials. But you probably don’t need that on day one. Start with SSM, migrate specific secrets to Secrets Manager later if you need rotation.

And please, don’t set up HashiCorp Vault unless you have compliance requirements that specifically mandate it. You’re now operating a distributed system just to store passwords. That’s not simplifying your life.

ECS Logging and Monitoring: Use CloudWatch

Every team wants to evaluate Datadog, New Relic, Honeycomb, and then maybe self-host Prometheus and Grafana “for cost savings.”

Stop. Use CloudWatch.

Add this to your task definition:

{
  "logConfiguration": {
    "logDriver": "awslogs",
    "options": {
      "awslogs-group": "/ecs/my-service",
      "awslogs-region": "us-east-1",
      "awslogs-stream-prefix": "ecs"
    }
  }
}

Done. Your container logs go to CloudWatch. You can query them with Log Insights. Enable Container Insights and you get CPU/memory metrics. Set up a few alarms. You now have better observability than 80% of startups.

Datadog is genuinely good software. I like it. But it costs $15+ per host per month from day one, and you need to manage another vendor relationship. You can add it later when you actually need distributed tracing or APM.

Self-hosted observability is a trap. I’ve seen teams spend months building ELK stacks and Prometheus clusters. That’s infrastructure work that doesn’t ship features. Unless you have a dedicated platform team, don’t volunteer for this.

The Actual Pattern Here

Look at what I recommended:

Fargate over EC2
Internal ALB over Cloud Map or Service Connect
GitHub Actions over CodePipeline or Jenkins
SSM over Secrets Manager or Vault
CloudWatch over Datadog or self-hosted

Every single choice optimizes for the same thing: less stuff to manage.

Yes, some of these cost slightly more money. Yes, some of them are less flexible. But they all share one property: they let you ship faster and debug easier.

And here’s what nobody puts in their architecture decision records: all of these choices are reversible.

Fargate to EC2? Task definitions work on both.
ALB to Service Connect? Just DNS changes.
SSM to Secrets Manager? Same integration pattern.
CloudWatch to Datadog? Add the agent, keep CloudWatch as backup.

The “wrong” choice costs you maybe a few hundred dollars a month in inefficiency. The debate about the “right” choice costs you weeks of engineering time.

What I’ve Actually Seen Happen

Teams that follow this advice ship in about a week:

Day 1-2: Fargate cluster up, first service running
Day 3: ALB routing traffic, services talking to each other
Day 4: GitHub Actions deploying on push to main
Day 5: Secrets in SSM, logs in CloudWatch, basic alarms set up

Week 2: Building features.

Teams that “do it right” are still having meetings about networking topology in week 6.

I’ve watched startups run out of runway while their infrastructure was still “almost ready.” I’ve seen senior engineers burn out on DevOps work instead of building the product that got them excited in the first place.

Your Python app on Fargate with CloudWatch logs isn’t going to fall over at 1,000 users. Probably not at 10,000. By the time scale is actually a problem, you’ll have the traffic data and revenue to solve it properly.

Ship first. Optimize later.

If you found this helpful, share it on X and tag me @muhammad_o7 - I’d love to hear about your ECS deployment experiences. You can also connect with me on LinkedIn.

Need Help? I’m available for AWS and DevOps consulting. If you’re stuck in ECS decision paralysis or need help getting to production faster, reach out via email or DM me on X/Twitter.

[RIDGELINE] The Walk and Talk, Nagano Kiso-ji

Craig Mod — Writer + Photographer — Thu, 18 Dec 2025 02:00:00 GMT

Ridgeline subscribers —

I’ll die on my dumb hill, the one where I say: the best time to visit and walk (most) of Japan is the end of November and the start of December. I think a lot of folks have a kind of North-Eastern-American mentality, where by the time December hits New York City, snow is falling and there’s a too-sharp bite to the air. Not so in Tokyo, or anywhere else west and south of the city.

2025-12-18

ho.dges.online — Thu, 18 Dec 2025 02:00:00 GMT

How To Win Titular Metagames

taylor.town — Thu, 18 Dec 2025 02:00:00 GMT

This is how this essay's title evolved

Quick Post: How I Think About Finishing Holes

Wigs on the Green — Wed, 17 Dec 2025 18:02:27 GMT

And why I think the 9th at Soule Park is such a great one

Tests vs Business Value

DEV Community: John Mitchell — Wed, 17 Dec 2025 17:06:29 GMT

Tests are in a higher level language, much simpler than app code. But, they are NOT free!

A test which is wrong, or doesn't match business expectations, is worse than no test at all. With no test, you can tell you don't understand how the code works in some situations. With a wrong test, the bad info gets lost among the other tests.

One time as a DevOps person I tried to help the App Devs with their work. A test failed. But I didn't understand the feature nor code nor the test well enough to know which one to fix! I did NOT want to "just make it work", that would be much worse than doing nothing. So I did nothing and moved on. I was... very salty that an expert Dev like myself couldn't help a simple code/test problem, but that was the best value I could provide: do nothing, there's definitely a bug, I can't fix it.

Junior Broken Feedback Loop

DEV Community: John Mitchell — Wed, 17 Dec 2025 17:05:41 GMT

It's a thinking challenge, not an AI challenge.

A while back, a junior asked me a question. They wanted to do X, they had code, with error Y. So they searched for it, got a page on Stack Overflow, pasted "the answer", then got a new and different error.

They:

didn't understand the original code
didn't understand the original error

This is fine. They then searched for the error and found a relevant page.

This is also fine. However, they:

cut-pasted "an answer" from SO without understanding if it was relevant or not

The junior was hoping to work with a Puzzle: adding information will gradually give them a solution. In practice they are working with a Mystery: more information makes the task harder since they can't distinguish between different aspects.

I focused them on a few relevant details and let them go to it.

AI: From Homer to ChatGPT

Ecce Homology on Bastian Grossenbacher Rieck's personal homepage — Wed, 17 Dec 2025 10:34:40 GMT

AI is omnipresent. With speculations on its capabilities running rampant, it is time to slow down a bit and assume a broader perspective. This is an article I wrote for a general audience, so if you are already in the know, please forgive me for taking some shortcuts for the sake of exposition.

Automatons In The Iliad

As it turns out, AI has been with us for much, much, longer. Already Homer describes attendants of Hephaestus, the god of blacksmiths and artisans, in the Iliad:

Grasping a thick staff he limped from the forge, supported by servants made of gold, fashioned like living girls, who attended swiftly on their master. As well as the use of their limbs they had intellect, and the immortals gave them skill in subtle crafts.

Somewhat tellingly, we would refer to such contraptions as “automatons,” which comes from the Ancient Greece word αὐτόματος (automatos), composed of “self-” and “thinking.” This already provides some insights into what we humans hope AI to be.

The Mechanical Turk And The Difference Engine

Moving from myth to mechanics, we find the 18th century to be the heyday of all types of clever automatons, including filigree music boxes (which our modern mind would probably not directly associate with anything AI) or contraptions like the infamous “Mechanical Turk”. Created by a certain Wolfgang von Kempelen, this machine was advertised as being able to play chess against a human player. Unfortunately, but maybe not unsurprisingly, it turned out to be a cleverly designed fake: The box essentially had enough space to hide a human player. Before people found out, the “Mechanical Turk” was a sensation (and rightfully so) since it appeared to mechanize that which used to be solely under the purview of humans.

All in all, however, the creativity of that epoch was restricted by the available technology. Thus, most automatons from that epoch, regardless of how cleverly designed and crafted they might have been, are just too specific to be considered AI. Nevertheless, an interesting anecdote by none other than Charles Babbage, creator and programmer of the difference engine, i.e., one of the precursors of the modern computer. Babbage wanted to solve polynomial equations faster and more precisely; when presenting his machine, he made the following entries in his journal:¹

On two occasions I have been asked, “Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?” […] I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.

Overpromising & Underdelivering?

Arriving finally in our times, AI and its promises were rediscovered. In 1956, leading scientists met at the Dartmouth Workshop, widely considered to be the creation of AI as a modern research field. Like our own research, the initial brief was widely optimistic and considered that about two months (!) would be sufficient to reach the following aims:²

[…] The study is to proceed on the basis of the conjecture that every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it. […] We think that a significant advance can be made in one or more of these problems if a carefully selected group of scientists work on it together for a summer.

Despite bringing about many new ideas (including expert systems and ideas for the first “artificial” neural networks), the workshop did not manage to bring AI into the public eye. This changed briefly in 1996, when Garry Kasparov played chess against “Deep Blue”—and lost. However, as much as this was a milestone for rule-based systems and AI in general, “Deep Blue” was a research cul-de-sac; modern neural networks are operating based on different paradigms, and “Deep Blue” was not even close to a general-purpose device.

The Revolution Has Good Graphics

Skipping over a couple of years, the breakthrough finally happened around the year 2012. Mostly driven by the availability of modern graphics cards, i.e., Graphics Processing Units (GPUs), neural networks essentially became feasible over night.³ The primary idea of such networks is to combine many small computational units, dubbed the “neurons,” which receive an input signal and may slightly modify it to pass it on to other neurons using trainable weights (more about that later). By arranging neurons hierarchically in different layers, an input signal (such as an image) can be iteratively transformed into an output signal (such as the probability that the image contains a dog).

To train such neural networks, we require vast amounts of data. Ideally, this data should be of high quality and diverse (whatever that might mean for a given application). A very simplistic approximation to what happens during the training process of neural networks is that the neural network is shown data and the expected output. Its internal weights are then adjusted such that the actual output more closely matches the expected output. By repeating this countless times and with a sufficiently large dataset, the hope is that at some point, the neural network will have picked up the underlying pattern and generalize to hitherto-unseen data. Despite decades of progress, training such a neural network remains something of an art, and numerous interesting unexpected phenomena arise during training. This did not stop the empirical progress, and after several “victories” in the field of computer vision, neural networks started transforming other fields. Already in 2018, three visionary AI researchers of the 1980s—Yann LeCun, Yoshua Bengio, and Geoffrey Hinton—received the “Turing Award,” one of the highest honors in computer science. Together with other pioneers like Jürgen Schmidhuber and Fei-Fei Li, these researchers could be considered the godparents of modern AI.

Pay Attention!

The next revolution happened thanks to the Attention Mechanism, which provided a neural network with a way to assign different parts of its inputs different weights, denoting their importance for a specific task. The resulting architecture, the transformer, turned out to be of general use, enabling, among other things, improved translation engines. This led to neural networks being capable to make use of inputs in the form of natural language, thus encroaching on humanity’s primary domain, viz., our capability of wielding language. Again, through vast amounts of data, often painstakingly annotated by humans, OpenAI managed to create one of the first generally usable large language models, dubbed ChatGPT. The true genius of this model is that it makes a plethora of tools available through language. No more arcane command-line inputs or scripts, but instead incantations, i.e., prompts, that remind me very much of magic spells…

Whatever our own opinions on AI, the transformation is already happening now, and large language models are ubiquitous. The use of language as the primary way of communication makes models appear “intelligent,” despite the mechanisms being essentially the same as in the previous decades, involving “just” a larger amount of data and compute. Whether this is a difference in degree or a difference in kind remains to be shown. However, there is at least one major distinction to known special-purpose machines like the aforementioned difference engine: Such machines typically make no mistakes in the calculations for which they were constructed (setting aside the fact that floating-point calculations are still hard to do with finite memory). This precision comes at the price of being fundamentally limited. Large language models do not exhibit such limitations a priori, but all their cognition is based on their inputs. If ChatGPT reads that people write about Switzerland having mountains, it will “learn” said fact, but it would equally be “happy” with learning that Switzerland is an almost-planar country. Hence, a lot of human intervention is required to teach AI the “right” things—and we should not be content with that type of training happening behind closed doors! Moreover, given the fundamentally stochastic nature of these models, it is not guaranteed that a model will always describe the right things. Unwillingly, it may hallucinate new “facts,” including references to non-existent articles or books. Some researchers thus believe that modern large language models will ultimately suffer the fate of “Deep Blue” and turn out to be too specific to be of long-term general use. In a recent WSJ article, Yann LeCun even discourages aspiring PhD students to work on large language models!

The Future Is Here And (Sort Of) Evenly Distributed

Whatever the future may hold, seemingly “modern” AI is now obviously there, and it is a technology that demands a lot from us. It challenges our beliefs, our systems, and our ways of living. Like any other technology, it has the potential for good and for evil. Unlike other technologies, however, AI is much more seductive since it promises short-term cognitive shortcuts that may result in long-term deficits.⁴ Moreover, modern large language models pretend to be persons, but at least for now, this is most likely⁵ just a facade and there is a lot of cognition but no consciousness. This does not prevent many users to treat their large language model as a person, though, and trust its utterances. Such trust can be misplaced and turn out fatal. As a society, we thus have to ask ourselves how we want to deal with AI. Do we treat everything it like something out of Pandora’s box or do we rather want to consider it as something straight from the horn of Amalthea? Regardless of our stance, everyone should at least understand the basics of this technology, lest the new relationship between human and machine turns out to be a toxic one.

(This is an extended and translated version of my essay on AI, appearing in UNIVERSITAS.)

“Passages from the Life of a Philosopher,” 1864 ↩︎
This makes me feel less bad when reflecting upon my own research proposals. ↩︎
The readers familiar with neural networks may have to pardon that I am glossing over a lot of details here. ↩︎
While AI is famously compared to mechanical calculators, I think this is a half-baked argument at best. We still need to teach students basic arithmetical skills so that they may hopefully understand what calculations are all about. Even a TI-82 will not solve your homework if all you do is mash buttons at random. ↩︎
At least I hope so, because I find the idea of an enslaved conscious entity to be loathsome. ↩︎

Listening Social Media for B2B Customer Pain Points

Bhupal's Web Page — Wed, 17 Dec 2025 09:20:34 GMT

In the world of B2B social listening, many companies make a critical mistake: they track the Topic, not the Pain. If you sell a CRM, tracking “Customer Relationship Management” is a discussion. Tracking a specific point of friction, like a competitor’s high price or a missing feature, is a wallet-opening moment. Your goal is to […]

“Testing the limits of the world around you”

🦉 olshansky 🦁 — Wed, 17 Dec 2025 08:25:03 GMT

“”

Current LLM tooling makes understanding optional

Vladimír Zdražil Posts — Wed, 17 Dec 2025 08:09:38 GMT

We usually talk about LLM tooling in terms of output: does the code work, does it pass tests, does it give me what I want? We talk far less about how it shapes our thinking during development.

Every tool does this. Compilers, IDEs, REPLs, debuggers, they don’t just help you get more done. They incentivize by making some things easy and some hard. LLM tools are no different.

The problem is not LLMs themselves, but that the way we currently design and evaluate them incentivizes skipping understanding.

What are we actually optimizing?

We evaluate LLM tooling almost entirely on output-first metrics:

Did it produce working code?
How fast did it do it?
How little effort did the user need to expend?

But in software engineering, especially for systems that must evolve, producing correct output is not enough. Keeping the ability to understand and reason about the system over time is.

Understanding is not “Knowing that it works”

Understanding isn’t having seen the system work or noticing that changes haven’t broken it. It’s being able to reason about how the system behaves.

That means having a mental model of:

what always has to stay true,
what limits the system,
the trade-offs it makes,
and the ways it can fail.

This kind of understanding can’t be added later. It forms while the system is being built.

If no one ever forms it, it never gets built into the system, and the system never acquires a stable internal logic. It becomes a pile of behavior that happens to work. Neither programmers nor LLMs can reconstruct that mental model after the fact. There’s nothing stable to reason about because it was never there in the first place.

That might be acceptable for prototypes, but it’s a problem for production systems.

Essential effort vs. incidental effort

Not all effort is bad.

Incidental effort: boilerplate, ceremony, mechanical repetition, should be eliminated.
Essential effort: problem decomposition, modeling, naming, tradeoff analysis, is what creates understanding.

LLM tooling is really good at removing incidental effort. The problem is that it also removes essential effort.

That distinction matters, because understanding doesn’t just appear once a system is finished. It emerges during the act of building, from the effort of having to make decisions and making sure they’re coherent.

How tools shape understanding

Every tool incentivizes particular behavior by where it introduces friction:

IDEs encouraged ceremony-heavy languages by making boilerplate painless.
REPLs encouraged you to explore by giving you a quick feedback loop.
Copy-pasting from StackOverflow required you to understand the problem well enough to search for it and then adapt the solution.

LLM tools make complete solutions cheap.

When the easiest path is to prompt, receive, and lightly review, understanding stops being a requirement. Knowledge gaps don’t block progress anymore. Because nothing forces you to confront them, you often don’t even notice they exist, or that you’ve made a questionable choice.

You can keep moving forward without breaking the problem down or forming a clear internal model of the system. But for systems that must evolve, this only shifts effort from the present to the future, rather than removing it.

Plausibility is the new risk

LLMs don’t just generate code. They generate plausible code.

It’s idiomatic. It’s clean. It looks finished.

We’re not great at separating “this looks familiar” from “I really understand this.” It’s like following the steps of a math proof and thinking you get it, until you try to redo it yourself and realizing you don’t.

Plausibility is dangerous because it removes many of the cues we used to rely on to notice that difference.

What actually breaks under change

The real test of an evolving system is not whether it works today, but whether it survives:

new requirements
unexpected failures
performance constraints
changing assumptions

That’s when you need to ask: does anyone — human or model — actually have a clear picture of how this system works?

If that understanding never formed while the system was being built, there’s nothing solid to reason about later. The system becomes brittle, not because the code is bad, but because reasoning about it is impossible.

At that point, better models don’t really help. If no one ever formed a stable mental model of the system in the first place, there’s nothing for any model to reconstruct after the fact.

The questions we should be asking

The question to ask is not only

Can LLMs write correct code?

It’s also:

Do these tools produce systems that can handle failure, novelty, and time?
And what must be produced alongside code so that understanding is unavoidable?

Right now, we’re mostly judging LLM tooling by how easily it produces working output. But evolving software doesn’t fail when code is wrong. It fails when we lose the ability to reason about it.

LLM tools shouldn’t help us lose that ability faster.

Naur, P. (1985). Programming as theory building. Microprocessing and Microprogramming, 15(5), 253–261.

Dream Prompter 1.2.0: The Evolution Continues

Terminal Thoughts — Wed, 17 Dec 2025 02:00:00 GMT

A few months ago, Dream Prompter launched as a GIMP plugin for AI-powered image generation and editing, supporting just one model: Google’s Nano Banana. Version 1.2.0 brings the total to nine. Here’s what changed and how it all came together.

🎄 Advent of EIP Day 2: Message Endpoints & Pipes and Filters

James Carr — Wed, 17 Dec 2025 02:00:00 GMT

Welcome back to the Advent of Enterprise Integration Patterns! Yesterday we got our hands dirty with Point-to-Point Channels and Competing Consumers, building the bones of Chronicle using OTP actors. We can send audit events and have them processed reliably by multiple consumers racing to grab work. Pretty cool! But here’s the thing: that implementation is tightly coupled to OTP. What happens when we want to deploy Chronicle across multiple machines? Or swap in RabbitMQ for a proper message broker?

What’s new in Ruby 4.0

Nithin Bekal — Wed, 17 Dec 2025 02:00:00 GMT

Ruby 4.0 will be released next week on Christmas day. This release brings a new JIT compiler, improvements to Ractors, a new mechanism to define namespaces called Ruby::Box, and a whole lot of other changes.

Zootopia 2

Code & Visuals — Wed, 17 Dec 2025 02:00:00 GMT

Disney Animation’s movie for 2025 is Zootopia 2, which is the studio’s 64th animated feature film. Zootopia 2 picks up where the first film left off, taking us deeper into the wonderful and wild animal world of the city. One of the really fun things about Zootopia projects is that each one expands the world further. The first film introduced the setting, the Zootopia+ series on Disney+ offered fun character vignettes to expand that world, and Zootopia 2 now takes us deep into the city’s history and to places both familiar and brand new. I’ve had a great time working on Zootopia 2 for the past two years!

From a technology perspective, sequels are always interesting to work on because they give us the ability to evaluate where our filmmaking capabilities presently stand compared against a known past benchmark; we know roughly what it takes to make a Zootopia movie already, and so we can see how much better we have gotten at it in the intervening years. I think Zootopia 2 is an especially interesting case because of how important the first Zootopia (2016) was in the history of Disney Animation’s technology development. For a bit of context: the decade of Disney Animation films leading up to Zootopia (2016) was a time when the studio was rapidly climbing a steep learning curve for making CG movies. Every film had technical challenges that called for the studio to overcome unprecedented obstacles. Zootopia (2016) similarly presented an enormous list of challenges, but upon completing the film I felt there was a stronger sense of confidence in what the studio could achieve together. A small anecdote about Zootopia (2016) that I am very proud of is that at SIGGRAPH 2017, I heard from a friend at a major peer feature animation studio that they were blown away and had absolutely no idea how we had made Zootopia.

Ever since then, the sense in the studio has always been “this movie will be hard to make, but we know how to make it.” This isn’t to say that we don’t have interesting and difficult challenges to overcome in each movie we make; we always do! But, ever since Zootopia (2016)’s completion, I think we’ve been able to approach the challenges in each movie with greater confidence that we will be able to find solutions.

The major technology challenges on Zootopia 2 ultimately were pretty similar to the challenges on Zootopia (2016): everything is about detail and scale [Burkhard et al. 2016]. The world of Zootopia is incredibly detailed and visually rich, and that detail has to hold up at scales ranging from a tiny shrew to the tallest giraffe. Most characters are covered in detailed fur and hair, and because the setting is a modern city, shots can have hundreds or even thousands of characters on screen all at the same time, surrounded by all of the vehicles and lights and zillions of other props and details one expects in a city. Almost every shot in the movie has some form of complex simulation or FX work, and the nature of the story takes us through every environment and lighting scenario imaginable, all of which we have to be able to render cohesively and efficiently. Going back and rewatching Zootopia (2016), I still notice how much incredible geometry and shading detail is packed into every frame, and in the nine years since, our artists have only pushed things even further.

To give an example of the amazing amount of detail in Zootopia 2: at one point during production, our rendering team noticed some shots that had incredibly detailed snow with tons of tiny glints, so out of curiosity we opened up the shots to see how the artists had shaded the snow, and we found that they had constructed the snow out of zillions upon zillions of individual ice crystals. We were completely blown away; constructing snow this way was an idea that Disney Research had explored shortly after the first Frozen movie was made [Müller et al. 2016], but at the time it was purely a theoretical research idea, and a decade later our artists were just going ahead and actually doing it. The result in the final film looks absolutely amazing, and on top of that, instead of needing a specialized technology solution to make this approach feasible, in the past decade both our renderer and computers in general have gotten so much faster and our artists have improved their workflows so much that a brute-force solution was good enough to achieve this effect without much trouble at all.

One of the largest rendering advancements we made on Zootopia (2016) was the development of the Chiang hair shading model, which has since become the de-facto industry standard for fur/hair shading and is implemented in most major production renderers. For Zootopia 2, we kept the Chiang hair shading model [Chiang et al. 2016] as-is, but instead put a lot of effort into improving the accuracy and performance of our hair ray-geometry intersection algorithms. Making improvements to our ray-curve intersector actually took a large amount of close iteration with our Look Development artists. This may sound surprising since we didn’t change the fur shader at all, but the final look of our fur is an effect that arises from extensive multiple-scattering between fur strands, for which small energy differences that arise from inaccuracies in ray-curve intersection can multiply over many bounces into pretty significant overall look differences. In an original film, if the look of a character’s hair drifts slightly during early preproduction due to underlying renderer changes, generally these small visual changes can be tolerated and factored in as the look of the film evolves, but in a sequel with established characters that have a known target look that we must meet, we have to be a lot more careful.

I’ve been lucky enough to have gotten to work on a wide variety of types and scales of projects over the past decade at Disney Animation, and for Zootopia 2 I got to work on two of my absolute favorite types of projects. The first type of favorite project is the ones where we get to work on a custom solution for a very specific visual need in the film; these are the projects where I can point out a specific thing in final frames that is there because I wrote the code for it. My second type of favorite project is ones where we get to take something super bleeding edge from pure research and take it all the way through to practical, wide production usage. Getting to do both of these types of projects on the same film was a real treat! On Zootopia 2, working on the water tubes sequence was the first project type, and working closely with Disney Research Studios to widely deploy our next-generation path guiding system was the second project type. Hopefully we’ll have a lot more to present on both of these at SIGGRAPH/DigiPro 2026, but in the meantime here’s a quick summary.

One of the big projects I worked on for Moana 2 was a total, from-scratch rethink of our entire approach to rendering water. For the most part the same system we used on Moana 2 proved to be equally successful on Zootopia 2, but for the sequence where Nick, Judy, and Gary De’Snake zoom across the city in a water tube transport system, we had to extend the water rendering system from Moana 2 a little bit further. During this sequence, our characters are inside of glass tubes filled with water moving at something like a hundred miles per hour, with the surrounding environment visible through the tubes and whizzing by. In order to achieve the desired art direction, the tubes had to be modeled with actual water geometry inside since things like bubbles and sloshes and murk and such had to be visible, so going from inside to outside the geometry we had to render was characters inside of water inside of double-sided glass tubes set in huge complex forest and city environments. To both give artists the ability to efficiently model this setup and efficiently render these shots, we wound up building out a customized version of the standard nested dielectrics solution [Schmidt and Budge 2002]. Normally nested dielectrics is pretty straightforward to implement in a simple academic renderer (I’ve written about implementing nested dielectrics in my hobby renderer before), but implementing nested dielectrics to work correctly with the myriad of other advanced features in a production renderer while also remaining performant and robust within the context of a wavefront path tracing architecture proved to require a bit more work compared with in a toy renderer.

During Moana 2’s production, we started work with Disney Research|Studios on a next-generation path guiding system in Hyperion that supports both volumes and surfaces (unlike our previous path guiding system, which only supported surfaces); this new system is built on top of the excellent and state-of-the-art Open Path Guiding (OpenPGL) library [Herholz and Dittebrandt 2022]. Zootopia 2 is the first film where we’ve been able to deploy our next-generation path guiding on a wide scale, rendering about 12% of the entire movie using this system. We presented a lot of the technical details of this new system in our course on path guiding [Reichardt et al. 2025] at SIGGRAPH 2025, but a lot more work beyond what we presented in that course had to go into making path guiding a really production scalable renderer feature. This effort required deep collaboration between a handful of developers on the Hyperion team and a bunch of folks at Disney Research|Studios, to the point where over the past few years Disney Research|Studios has been using Hyperion essentially as one of their primary in-house research renderer platforms and Disney Research staff have been working directly with us on the same codebase. Having come from a more academic rendering background, I think this is one of the coolest things that being part of the larger Walt Disney Company enables our team and studio to do. Our next-generation path guiding system proved to be a really valuable tool on Zootopia 2; in several parts of the movie, entire sequences that we had anticipated to be extraordinarily difficult to render saw enormous efficiency and workflow improvements thanks to path guiding and wound up going through with relative ease!

One particularly fun thing about working on Zootopia 2 was that my wife, Harmony Li, was one of the movie’s Associate Technical Supervisors; this title means she was one of the leads for Zootopia 2’s TD department. Harmony being a supervisor on the show meant I got to work closely with her on a few things! She oversaw character look, simulation, technical animation, crowds, and something that Disney Animation calls “Tactics”, which is essentially optimization across the entire show ranging from pipeline and workflows all the way to render efficiency. As part of Zootopia 2’s Tactics strategy, the rendering team was folded more closely into the asset building process than in previous shows. Having huge crowds of thousands of characters on screen meant that every single individual character needed to be as optimized as possible, and to that end the rendering team helped provide guidance and best practices early in the character modeling and look development process to try to keep everything optimized while not compromising on final look. However, render optimization was only a small part of making the huge crowds in Zootopia 2 possible; various production technology teams and the TD department put enormous groundbreaking work into developing new ways to efficiently author and represent crowd rigs in USD and to interactively visualize huge crowds covered in fur inside of our 3D software packages. All of this also had to be done while, for the first time on a feature film project, Disney Animation switched from Maya to Presto for animation, and all on a movie which by necessity contains by far the greatest variety of different rig types and characters in any of our films (possible in any animated film, period). Again, more on all of this at SIGGRAPH 2026, hopefully.

I think all of the things I’ve written about in this post are just a few great examples of why I think having a dedicated in-house technology development team is so valuable to the way we make films- Disney Animation’s charter is to always be making animated films that push the limits of the art form, and making sure our films are the best looking films we can possibly make is a huge part of that goal. As an example, while Hyperion has a lot of cool features and unique technologies that are custom tailored to support Disney Animation’s needs and workflows, in my opinion the real value Hyperion brings at the end of the day is that our rendering team partners extremely closely with our artists and TDs to build exactly the tools that are needed for each of our movies, with maximum flexibility and customization since we know and develop the renderer from top to bottom. This is true of every technology team at Disney Animation, and it’s a big part of why I love working on our movies. I’ve written only about the projects I worked directly on in this post, which is a tiny subset of the whole of what went into making this movie. Making Zootopia 2 took dozens and dozens of these types of projects to achieve, and I’m so glad to have gotten to be a part of it!

On another small personal note, my wife and I had our first kid during the production of Zootopia 2, and our baby’s name is in the credits in the production babies section. What a cool tradition, and what a cool thing that our baby will forever be a part of!

Below are some beautiful frames from Zootopia 2. Every last detail in this movie was hand-crafted by hundreds of artists and TDs and engineers out of a dedication to and love for animation as an art form, and I promise this movie is worth seeing on the biggest theater screen you can find!

All images in this post are courtesy of and the property of Walt Disney Animation Studios.

References

Nicholas Burkard, Hans Keim, Brian Leach, Sean Palmer, Ernest J. Petti, and Michelle Robinson. 2016. From Armadillo to Zebra: Creating the Diverse Characters and World of Zootopia. In ACM SIGGRAPH 2016 Production Sessions. Article 24.

Matt Jen-Yuan Chiang, Benedikt Bitterli, Chuck Tappan, and Brent Burley. 2016. A Practical and Controllable Hair and Fur Model for Production Path Tracing. Computer Graphics Forum (Proc. of Eurographics) 35, 2 (May 2016), 275-283.

Sebastian Herholz and Addis Dittebrandt. 2022. Intel® Open Path Guiding Library.

Thomas Müller, Marios Papas, Markus Gross, Wojciech Jarosz, and Jan Novák. 2016. Efficient Rendering of Heterogeneous Polydisperse Granular Media. ACM Transactions on Graphics (Proc. of SIGGRAPH Asia) 35, 6 (Nov. 2016), Article 168.

Lea Reichardt, Brian Green, Yining Karl Li, and Marco Manzi. 2025. Path Guiding Surfaces and Volumes in Disney’s Hyperion Renderer- A Case Study. In ACM SIGGRAPH 2025 Course Notes: Path Guiding in Production and Recent Advancements. 30-66.

Charles M. Schmidt and Brian Budge. 2002. Simple Nested Dielectrics in Ray Traced Images. Journal of Graphics Tools 7, 2 (Jan. 2002), 1–8.

Maintaining an open source software during Hacktoberfest

Bruno Croci — Wed, 17 Dec 2025 02:00:00 GMT

I was finalizing the first working version of bulletty when I realized it was close to Hacktoberfest, the event created by DigitalOcean where they give t-shirts for people who contribute to open source software (more specifically, when you complete 6 successful PRs during the month of October). So I thought it could be interesting to have people contribute and help me make the feed reader better, also bringing more visibility to the project.

I started by organizing the Issues in the project: one for each feature from the project roadmap and for bugs, with many details and images. Then I added appropriate tags, such as “Improvements”, “Bugs”, “Good First Issue”, and of course the “Hacktoberfest” tag. I also wrote a pretty generic CONTRIBUTING file, mostly explaining how to proceed when suggesting changes, reporting bugs or submitting a PR.

To make it public, a few days before October, I posted on my personal accounts on X, Bluesky and Mastodon, then posted on the /r/hacktoberfest subreddit. Then I figured out there’s an official Hacktoberfest discord server with a channel for people to recruit contributors, so I did it too. I tried Hacker News, but honestly was the channel where I got the fewest views.

In just a few days, I saw the star counter on GitHub go to almost a hundred. Got many replies on all the platforms and I considered it an absolute success. Then October started…

On the very first day, I started getting multiple comments on issues of people asking me to assign the issue to them. Without any type of discussion first:

People asking to be assigned to Issues

I thought that was a bit too quick and I realized that I didn’t want to assign issues to people without discussing what they’re planning to implement in the first place. Maybe if someone already came with a pull request, I could consider their implementation and would review the code and discuss if that’s the best way. But just assign them the issue and wait for whatever they came up with felt a bit too risky, because that meant that other people would not even check on that issue if someone is already on it.

So I updated the CONTRIBUTING file with some more information on how to work on the issues:

Working on Issues

First requirement: use the program. I’ve seen people wanting to contribute without using it. Issues will only be assigned to users when enough discussion about their implementation has taken place. It’s important that nobody keeps an issue assigned without making progress, as this prevents others from contributing. So, if you want to write code for an existing issue, start by discussing the issue and your proposed solution first.

I do think it’s fine if you submit a PR for a bugfix you made without prior discussion, as long as you take the time to explain the why and the how. In that case, the issue won’t be assigned to you until the merge is complete.

So I replied that user:

I have a knowledge!

I instantly suspected the user would be vibe-coding due to the way they described their proposal for the issue. So I asked, and they confirmed some sort of vibe-coding workflow. So I had to go and update the CONTRIBUTING file once again:

Generative AI use

I don’t want to go as far as prohibiting anyone from using AI. After all, at this point, some AI use is inevitable. However, purely vibe-coded PRs are not going to be approved. If you’re using AI to generate code, you must make it very clear. And you’ll have to own it and maintain it. I will review and ask as many questions as necessary about the code, and I reserve the right to judge whether I think the contribution is worth it or not.

Also, not properly communicating that you’re using generated code in your PR is considered dishonest. If I find out, I’ll have to close the PR.

I use some AI myself, it’s not the problem. However I see people simply delegating to an LLM to write all the code for them, and I think it’s just bad.

That user eventually submitted a PR for that:

Looks too detailed explanation for an implementation that didn’t even build

The PR didn’t even build; the code wasn’t formatted (despite me explicitly saying it’s important in the CONTRIBUTING file); the two commits were titled “Update readerscreen.rs”, without any logical division; there was even an instance of a method’s name that was changed, but without changing the name in the Trait it inherited from:

handle_events was changed to handle_event for no apparent reason

So many indications that the user just asked their own agentic copilot for the changes and just tried to submit the PR. I closed the issue with some harsh words, something like “please avoid wasting both our times”.

Some of the issues got people adding “attack plans” that looked very clearly LLM-generated, because they didn’t make much sense to begin with. For example, one of the issues is caching the feed library, something that needs to be done but can be as simple as keeping a local variable of the feed entries per feed source, instead of querying the disk on every interaction (which is still happening to this day). One user suggested very vague and nonsensical cache infrastructure right after affirming they were not vibe-coding:

interesting cache infrastructure

I remember reading from other maintainers that during Hacktoberfest, it was really common to get spammy PRs with mostly typo fixing, simple comments being added or removed, or plainly useless changes. Now, with AI coding and advanced agentic models where you just show your codebase and ask for modifications and it does it all in place, maintaining open source software is getting more complex. For simple tasks, it might not even be a problem, but I can see users contributing with big refactors that were completely machine-made, possibly introducing not only a series of bugs, but eventually creating a code that nobody fully understands. Simply because LLMs have no “theory”, as in Peter Naur’s “Programming as Theory Building”.

Plus, everyone seems to have their own conviction on what has been created with AI or not. This whole post is about how I dealt with possible AI generated contribution mostly based on the behaviour and messages of the user proposing them. But these could be just mistakes, maybe they were really just made by humans. For example, I see some people judging texts that are overly formatted with italics, bold and underline as something that LLMs could have done, but I myself do it quite a lot since forever. AI could be creating noise in the open source software community.

There were good contributions

Nevertheless, there were good contributions. After the first wave of weird PRs, some more well-intentioned people got interested and started contributing to the project. Highlight to these PRs:

A very important feature that was missing, the ability to navigate previous/next posts from the reader screen itself. The implementation taught me about Rc<RefCell<>> in Rust.

Feature: Read Later

The ability to store articles in a separate category to be read later. This was an extremely nice PR made by alfaarghya, after some very nice discussion on the best ways to implement it. He also contributed with other nice PRs during the time.

Some other PRs that I’ve reviewed and merged into the project were:

These inspired me so much that I ended up implementing many features during this time too. Since I was submitting PRs for myself to approve too, Hacktoberfest considered these and also sent me a t-shirt (that hasn’t arrived yet).

In the end it was a good idea. bulletty got some visibility, code contributions, many people also posting bugs and suggestions, even after the event. The project has now 250 stars on GitHub:

bulletty

Shell hinting function to guide me

Patterns, Code & Curiosity — Wed, 17 Dec 2025 00:00:59 GMT

Living in the terminal. The terminal is always there. The command line. All those commands available under my fingertips, it feels something. It feels like an endless possible stream of possibilities. Perhaps not endless, not far from it. Sometimes I can remember parameters to commands that I don’t run so often. But I still need […]

Fall photos of the dogs

Notes from the Burrow — Tue, 16 Dec 2025 20:58:00 GMT

This fall I’ve been trying to take more photos of my dogs especially when we’re at the park. It’s also led me down the path of editing. Kristen was teaching...

Goodhart’s Law: Why Your Green Security Dashboard Might Be a Red Flag

Security Wale — Tue, 16 Dec 2025 19:38:00 GMT

The most dangerous number in cybersecurity is a perfect score. Why 'Green' often means you aren't looking hard enough, and how to design incentives for reality.

Using Iceberg Catalogs in the Browser with DuckDB-Wasm

tobilg.com — Tue, 16 Dec 2025 17:42:18 GMT

With recent updates of DuckDB itself, DuckDB Wasm and the Iceberg extension it is now possible to query Iceberg catalog directly from the browser, with no backends. involved. Ex...

I’m a Tech Lead, and nobody listens to me. What should I do?

João Alves — Tue, 16 Dec 2025 11:26:34 GMT

In June 2018, I joined mytaxi (FREE NOW), a competitor of Uber in the ride-hailing space, as Backend Chapter Lead. I was looking for an opportunity to grow in technical leadership. Honestly, I did not even fully understand what “Chapter Lead” meant. After some research, I learned it was part of Spotify’s squad (team) and chapter (horizontal domain, such as iOS, Android, Backend, Data, etc.) model, as well as tribes (groups of squads organized around vertical domains, for example, everything related to drivers).

Note: this article is a translation from the original “Soy Tech Lead y no me hacen caso. ¿Qué hago?”, in Spanish.

The squads, tribes, chapters, and guilds model popularized by Spotify. Source.

That role had two main components:

Backend technical leadership (TL), driven by best practices and with a strong emphasis on continuous improvement. At the time, mytaxi was experiencing major traffic growth. Some services — for example, the one used to incentivize drivers to complete more rides — experienced significant traffic spikes and required improvements, re-architecting, and similar work. On top of that, there were a bit over 200 services to manage.
People management in a horizontal setup. The idea was that all backend engineers would report to either Ariel, the other Chapter Lead, or me, regardless of their team. This was not a very orthodox setup, but at the time, around 3–5 backend engineers were joining every month. There was a strong need to make people productive as quickly as possible, align on architecture, and keep the product moving.

I came in with no prior formal experience as a Tech Lead. I think I never read as much in my life as during the month between announcing I was leaving my previous job and joining mytaxi. Not only that. I had never really had a proper Tech Lead to learn from. What could go wrong?

---

The first day was very entertaining. I log into Slack and introduce myself to the infrastructure and platform manager. He says:

By the way, you have an incident in service X. Could you take a look?

Just like that. It is nine in the morning on a Monday, and we already have an incident. I do not even know where the logs are, Henning. After the initial shock, I managed to find the responsible team. They identified the issue, fixed it, and everything got resolved.

This first interaction made several things very clear to me:

Nobody really knows how to manage incidents, document what happened, or communicate progress. Great start.
There is no culture of doing incident reviews or extracting actions to prevent similar incidents in the future.
There is some coupling between domains. In this case, the Value Added Tax (VAT) concept was applied to two completely different use cases. A change in one of them caused the incident in the other.
Many people do not know how to debug. They look at me as if the logs were talking to me, or as if I were Harry Potter.

The good part was that there was clearly a lot to fix. I had a pretty clear idea of how engineering culture could be improved. On top of that, I had the Tech Lead title. This was going to be easy. Or maybe not.

---

👋 Hi, João here. This is the opening post of a series designed for Tech Leads and Engineering Managers who want to lead with greater clarity and intention.

“Traits of a good Tech Lead”
“I’m a Tech Lead, and nobody listens to me. What should I do?” ← This article
“KPIs, SLOs, and operational excellence”. Coming soon. Subscribe so you do not miss it.
To be continued…

I’m currently writing “The Tech Lead Handbook”, scheduled for release in H1 2026. The ideas in this series will form its core.

If you want to join the waitlist, you’ll get a 25% launch discount.

---

Trust

After that incident, I created an incident review document and suggested a small review of the tasks that should be prioritized to prevent it from happening again. I got carried away and created an initial presentation for the other backend Chapter Leads with a backend strategy. I do not remember it perfectly, but it included hexagonal architecture, a testing pyramid with contract tests to avoid breaking APIs used by mobile apps, and more. Days go by, and I start thinking:

Damn, nobody is listening to me. I put a lot of work into those slides and that strategy.

Today, the reason seems obvious to me. Titles do not grant influence. To influence, you need to build trust. And I had not earned enough of it yet to propose something so fundamental. Through my own experience and through coaching sessions, I have seen this exact mistake repeated several times throughout my career.

Years later, I discovered the well-known trust equation by Maister, Green, and Galford. It would have been incredibly helpful back then. It goes like this:

The trust equation. Generated with Gemini 3 / NanoBanana.

The first time I read it, my mind was blown because it described exactly what was happening to me. Let’s break it down:

Credibility: knowing what you are talking about and having technical judgment. When you say something, people feel it is well-founded. In 2018, I might have had some of this credibility, but it had not yet been proven in that context, with those people, with those systems. I was coming from the outside. Imported credibility is always worth less — unless you come from a FAANG or have built a strong personal brand — than credibility earned on the ground.
Reliability: doing what you say you will do. Being consistent and showing up when needed. In a high-paced environment like mytaxi, this matters a lot. In those first days, I was still learning where the logs lived. It is hard to demonstrate reliability if you do not even control the map.
Intimacy: people feel they can talk to you, that you will not leave them exposed, and that you understand their fears and doubts. For a TL, this is more important than it seems. Without this, any technical proposal feels like a judgment. And when people get defensive, everything slows down.
And then there is the denominator: self-orientation. When your proposals seem to serve your own agenda more than the team’s needs, trust collapses. That was my mistake. I arrived with a strategy too early, without listening, without seeing what they actually needed, without having earned the moral right to propose it.

In other words, even if my ideas were good, the equation still did not work out. I had some credibility, a bit of reliability still to build, intimacy yet to be created, and too much self-orientation. The result was obvious. Low trust.

Two key moments

Over time, I realized that trust is not built through big speeches, but through concrete actions that solve real, everyday problems. Looking back, two obvious moments accelerated the team’s shift in how they perceived me.

Regulatory complexity

Because mytaxi competed with Uber in a highly regulated taxi market, with very local regulations across Europe, the application needed to support multiple variants of the same flow. This led to the proliferation of dozens of configuration flags across all services. The result was chaos. Nobody knew for sure what was enabled in each city, what affected iOS, what affected Android, or where each option was actually defined. To make matters worse, the configuration was spread across roughly 200 services.

One day, Maria — an Agile Coach — talked to me very directly about this pain. I did what I knew best at the time. I built something. I put together a portal — a bit rough, to be honest — that queried the configuration APIs of all services and aggregated that information by functionality, country, or city. Features could be browsed by city or by name. The website was very simple, generated from an HTML template by a Python service.

The features could be queried by city or by name. The website was very simple, with HTML generated by a Python service.

Suddenly, at a glance, anyone could see what was enabled and where. It was not pretty, but it solved a problem. More importantly, it showed that I was there to help them work better (credibility), not to impose an abstract technical agenda. Soon after, other teams started using the portal, including Product Owners, QA, and even Operations. Without intending to, it became an organizational alignment tool. And it led to something even more interesting. Other engineers started contributing.

Once they saw the value it created, several colleagues proposed improvements, fixed minor bugs, and added features I had never even considered. One of them built a small website to visualize city zones, which solved a long-standing pain for teams working with geofencing or driver-passenger assignment. Another automated part of the flag update process. Someone else added metrics to detect inconsistent configurations across platforms.

What started as a quick hack turned into a small ecosystem of internal tools that reduced uncertainty, sped up decisions, and made the team’s life a little easier every week.

That domino effect taught me something important. When you solve a real problem and make it visible, people join in. Trust is also built that way, by inviting others to improve what you started and celebrating when they do it better than you.

Debugging

The second moment concerned something much more human. Helping people debug. I have never considered myself especially smart, but I have always been very systematic when connecting error messages, code, hypotheses, and system behavior. To my surprise, many people saw this as almost magical. It was not magic. It was a mix of experience, fundamentals, intuition, knowing where to look, and not being afraid to dive into third-party library code.

I started pairing with colleagues during incident resolution (intimacy), teaching them to formulate and discard hypotheses, read logs with intent, and distinguish symptoms from root causes. I proposed incident-review practices that improved the quality of our responses and helped us learn collectively.

Without realizing it, these two contributions did more for my reputation than any presentation or strategy deck. Building helpful things and standing by people when the system is on fire creates more trust than any title. That was when my ideas finally started gaining traction. Interestingly, these two actions reduced my self-orientation to zero. I stopped thinking about “my strategy” and started thinking about “our work”.

What would you tell your 2018 self?

Looking back, one idea stands out. No, TLs don’t earn influence just because “it is their role”. It is earned every day, not through speeches, but by solving painful problems and being present when people need real support.

If you are in a similar situation, here is some advice I wish I had received in 2018:

Before proposing a strategy, first understand what actually hurts your team.
Pick one or two actions that deliver immediate value and execute them.
Talk less about architecture and more about how your proposal reduces toil, risk, or uncertainty.
Do not try to prove you are the smartest person in the room. Try to help others do their job better.
Feedback cycles, unlike code, are slower. They are measured in weeks or months. Be patient.
And above all, remember that trust is cumulative. It is earned in every interaction.

Technical influence does not start with a title. It begins with the visible impact you create. Because when a TL feels unheard, the solution is not to speak louder.

It is to change the conversation. And to start from the only place you truly control: your own behavior.

---

🎁 Want to put this into practice with your team tomorrow? Subscriber-only gift

Many Tech Leads feel unheard because EMs, TLs, and the rest of the team operate with different expectations that no one has made explicit. That friction is not resolved with more meetings or more processes. It is determined with clarity. To help you close that gap, I have prepared a FREE alignment toolkit with three practical tools:

For Tech Leads: a self-assessment traffic light to fight impostor syndrome and clearly understand where you are creating value and where you are burning out.
For Engineering Managers: an evaluation traffic light to give objective feedback based on behaviors, not gut feelings. Help your Tech Leads have a real impact.
For the team: an operational principles template to stop debating the same decisions every week and create shared criteria.

In addition, to complement this article, I will include a concrete plan for your first 90 days as a Tech Lead: what to observe, what to prioritize, what to avoid, and how to build trust through small, visible steps. It is the plan I wish I had had during my first week at mytaxi.

If you have already downloaded the toolkit, you do not need to do anything. You already have the updated version and will automatically receive the 90-day plan.

If you are not yet subscribed, subscribe, complete this form, and I’ll send you the kit so you can move from intention to action. It is FREE!

---

— João

Yuptime

Brian Sunter — Tue, 16 Dec 2025 10:57:22 GMT

A Kubernetes-native uptime monitor. Monitors are CRDs, state lives on the CRD's status subresource, and each check runs in its own throw-away Job pod.

What I’ve been up to lately

Notes from the Burrow — Tue, 16 Dec 2025 08:57:59 GMT

When I first signed up for Pika, I had this rush of energy to write and I have a few blog posts that I keep meaning to finish up but...

Piecemeal Formal Verification: Cloudflare, Java Exceptions, and Rust Mutexes

Gavin D. Howard — Tue, 16 Dec 2025 03:13:20 GMT

Could we have cheap formal verification? Yes, and this post describes how.

Jobs are roles now

june.kim — Tue, 16 Dec 2025 02:00:00 GMT

My 2025 reads

Alexander's Blog Blog — Tue, 16 Dec 2025 02:00:00 GMT

How big things get done

🎄 Advent of EIP Day 1: Integration Styles & Point-to-Point Channels

James Carr — Tue, 16 Dec 2025 02:00:00 GMT

Welcome to Day 1 of the Advent of Enterprise Integration Patterns! Today we tackle the foundational question every distributed system must answer: how do systems share information? Can someone just call me!? Chapter 2 of Enterprise Integration Patterns lays out four fundamental integration styles. Understanding these options and their trade-offs is essential before diving into the patterns themselves. Let’s examine each one, drawing from real-world experience, and then bootstrap Chronicle with our first pattern implementation.

“Photographing Potrero Hill” is in local coffee shops

Thomas Hunter II — Tue, 16 Dec 2025 02:00:00 GMT

AI can only solve Boring Problems

David Buchanan's Blog — Tue, 16 Dec 2025 02:00:00 GMT

Field Notes from a Centaur (126)

Artificial Insights — Mon, 15 Dec 2025 18:34:14 GMT

Welcome back to Artificial Insights, your weekly attempt to make sense of scattered ideas.

Announcing Key Transparency for the Fediverse

Dhole Moments — Mon, 15 Dec 2025 16:45:54 GMT

I’m pleased to announce the immediate availability of a reference implementation for the Public Key Directory server. This software implements the Key Transparency specification I’ve been working on since last year, and is an important stepping stone towards secure end-to-end encryption for the Fediverse. You can find the software publicly available on GitHub: To get […]

Humba Ventures Deep Tech Office Hours (Dec 2025)

Coding VC — Mon, 15 Dec 2025 15:15:27 GMT

About a decade ago, when I was still early in my VC career, I held founder/VC office hours for a few years around the holidays.

The Compensation Commandments

Stay SaaSy — Mon, 15 Dec 2025 08:59:22 GMT

Compensation is difficult. Even more than that, it is sensitive, business critical, and often has almost nothing to do with the rest of your job as a leader. Here are some rules for making compensation decisions effectively and efficiently.

2025-12-15-001

Srijan Choudhary, all posts — Mon, 15 Dec 2025 08:55:00 GMT

A small elisp snippet that I found useful. I often switch between terminals and #Emacs, and they have slightly different behaviors for C-w. This makes it behave the same in Emacs as it does in bash/zsh/fish etc - deletes the last word. It retains the kill-region behavior if a region is actually selected. (defun kill-region-or-backward-word () "If the region is active and non-empty, call …

Drawing parallels between home renovation and software development

./techtipsy — Mon, 15 Dec 2025 06:00:00 GMT

I had a lot of time to think during an apartment renovation and how it's eerily similar to what I do at my day job.

Monica and Brandy - “The Boy is Mine Tour” - in Atlanta

The Digital Nomad — Mon, 15 Dec 2025 05:52:12 GMT

This concert was a little different than most. While most of the time each artist comes out and does their set, they took turns doing a few songs each and did a few together.

There isn’t too much else to say, it was pretty good.

We stayed at the Omni Hotel and took the Marta train back and forth. State Farm Arena was in walking distance

Learning from Gary Vol. 2

Something About Cats — Mon, 15 Dec 2025 05:44:20 GMT

Resisting curation

Full Unicode Search at 50× ICU Speed with AVX‑512

Ash's Blog — Mon, 15 Dec 2025 02:00:00 GMT

ICU gets Unicode right and pays for it. This post shows a different approach: fold-safe windows, SIMD probes, and verifiers for fast UTF‑8 search.

🎄 Advent of Enterprise Integration Patterns

James Carr — Mon, 15 Dec 2025 02:00:00 GMT

Since returning to Zapier, I’ve been building the features enterprise customers crave for managing automation at scale. Event-driven architectures, message routing, guaranteed delivery, audit trails. The stuff that enterprise buyers expect as table stakes. It’s reminded me how much this foundational knowledge matters. One thing keeps coming up: audit logging. Every enterprise customer wants to know what happened, when, and by whom. It sounds simple until you’re building it for the fifth time, wiring up the same patterns to yet another data store.

Xorg Desktop Manager

Cookie Engineer's Web Log — Mon, 15 Dec 2025 02:00:00 GMT

How to use XDM on ArchLinux with a minimal xconsole login screen and a feh background

Everything about cargo_attach

River Writes - A MediaWiki Blog — Mon, 15 Dec 2025 01:50:34 GMT

What does #cargo_attach do? How do you use it? And more

What does ChatGPT think about Viktor Orban's 15 years as Hungary's leader?

Bytepawn - Marton Trencseni — Mon, 15 Dec 2025 01:00:00 GMT

I asked ChatGPT to summarize the top 10 positives and negatives of Orban Viktor's 15 years as Hungary's leader.

PaxosLease: Extending and Releasing Leases

Bytepawn - Marton Trencseni — Mon, 15 Dec 2025 01:00:00 GMT

This article extends the basic PaxosLease algorithm with practical lease renewal and explicit release semantics, showing a full working Python/Flask implementation and explaining why the protocol remains safe without disks or synchronized clocks.

Loot: Season 3

🦉 olshansky 🦁 — Sun, 14 Dec 2025 23:07:50 GMT

Olshansky's review of Loot: Season 3

The Body Electric: Manipulating Large-Scale Anatomy Through Bioelectricity (presentation runthrough)

Liza Shulyayeva — Sun, 14 Dec 2025 23:01:33 GMT

My final 15-minute presentation for the Frontiers in Life Sciences course I’m taking is this evening, so I’ve been finishing up my slides and doing some runthroughs. Below is a practice recording of what I intend to present.

Hash tables in Go and advantage of self-hosted compilers

Artem Golubin — Sun, 14 Dec 2025 19:14:08 GMT

Recently, I was looking at the Go codebase that was using map[int]bool to track unique values. As some of you may know, Go has no set data structure. Instead, developers usually use hash maps (key-value data structure).

The first idea that comes to mind is to use map[int]bool, where keys are integers and values are booleans. But experienced Go developers know that Go has an empty-struct type that can be used for maps: map[int]struct{}.

The benefit of such a type is that it occupies zero bytes in memory; it's a so-called zero-sized type. The compiler knows this and uses it to your advantage when it can. In this case, it should omit storing values and keep only keys.

So when I saw the bool struct, my first thought was to switch to map[int]struct{} to save some memory. In theory, that map can hold more than 100 000 integers.

To my surprise, this change had no effect on memory consumption when running in production.

[......]

Course: Large Language Models and Generative AI for NLP — 2025

Stories by Dmitry Kan on Medium — Sun, 14 Dec 2025 16:11:01 GMT

Course: Large Language Models and Generative AI for NLP — 2025

This year we—Aarne Talman (AMD), Jussi Karlgren (AMD), and myself (TomTom -> Aiven)—have been teaching the LLM and Gen AI course for the second year in a row, for students of different departments of the University of Helsinki.

In my 2-week part, I focused again on RAG (Retrieval Augmented Generation) and Applications. One change since 2024 was the addition of Agentic RAG, where the following basic RAG diagram:

Vanilla RAG workflow

transforms into an RAG with AI Agents, where each AI Agent has these components:

Components of an AI Agent

Comparing vanilla RAG and Agentic RAG:

How Vanilla RAG compares to Agentic RAG (courtesy: Weaviate blog)

I have also sped up the RAG UI to support the local Ollama model in addition to the Gemma-2B one.

All the code and slides are online, together with the project assignments: https://github.com/Helsinki-NLP/LLM-course-2025

JJ Cale

Nicola Iarocci — Sun, 14 Dec 2025 12:29:22 GMT

We watched A Private Life in the theatre yesterday, a fine, funny and intriguing French film set in Paris with a solid Jodie Foster as protagonist.

But I’m here for the closing piece of the soundtrack, the one you hear over the end credits: Don’t Go To Strangers, by JJ Cale. I immediately reached for Shazam while Serena looked it up on Spotify.

Now I’m spending this whole Sunday morning listening and reading about the artist and the Tulsa sound movement he originated. Despite his reticence and all-around low profile, he was no small feat and inspired many a great artist in the 70s, 80s, and 90s. Just to get your bearings, he’s the original author of Cocaine later brought to fame by Eric Clapton.

A Plea by Flea

Nicola Iarocci — Sun, 14 Dec 2025 11:15:52 GMT

I reluctantly admit that it was Spotify’s Discover Weekly that let me discover Flea’s new solo single, A Plea. It’s jazz, and it’s beautiful. There are echoes of Fela Kuti and Sun Ra in it or, well, that was my first thought.

The lyrics may sound naive at first, but they’re not. Instead, they strike me as lucid and match my general feeling about what’s going on lately, the risks we’re taking as a society, and what we should do to move beyond and improve ourselves. The video is 100% Flea, and it’s adorable (it is directed by his daughter).

Coding is Solved (And That's Fine)

Greg Herlein — Sun, 14 Dec 2025 10:00:01 GMT

“We are nearly at coder-equivalency for economically useful coding. A sufficiently experienced software engineer can now write >90% of production-ready code purely through prompting.” Yes, exactly.

Wrapping Up 2025 - The Year Of MCP

Den Delimarsky — Sun, 14 Dec 2025 02:00:00 GMT

The past year has, arguably, been all about Model Context Protocol. This is a reflection on the past twelve months, and an outlook on the year to come.

Gemini 3 Pro vs GPT 5.2: A Blind Test Reveals Code Red DNA

Prasham H Trivedi — Sun, 14 Dec 2025 02:00:00 GMT

I ran a blind A/B test between Gemini 3 Pro and GPT 5.2 on my slash command converter. Same prompt, same input. One gave me 60 lines I could use. The other gave me 250 lines I had to rewrite. The difference wasn’t the prompt-it was the training.

Markets as the ultimate RL environment

JonLuca's Blog — Sun, 14 Dec 2025 01:58:52 GMT

Why financial markets are an unusually pure, brutal, and adversarial reinforcement learning environment.

Tether Makes Unsolicited $1B Bid For Soccer Club Juventus

The Techee — Sat, 13 Dec 2025 18:26:32 GMT

Tether Limited, the company behind the world’s most widely used stablecoin, has made an unsolicited bid to acquire Italian soccer club Juventus FC (BIT: JUVE). The El Salvador-based crypto giant has offered to acquire a 65.4% controlling stake in Juventus from Exor, a holding company of the prominent billionaire Agnelli family. The Agnelli family has […]

The post Tether Makes Unsolicited $1B Bid For Soccer Club Juventus appeared first on The Techee.

Introducing arborium, a tree-sitter distribution

fasterthanli.me — Sat, 13 Dec 2025 12:00:00 GMT

About two weeks ago I entered a discussion with the docs.rs team about, basically, why we have to look at this:

When we could be looking at this:

And of course, as always, there are reasons why things are the way they are. In an effort to understand those reasons, I opened a GitHub issue which resulted in a short but productive discussion.

I walked away discouraged, and then decided to, reasons be damned, attack this problem from three different angles.

Database Proxies: Connection Management at Scale

Engineering At Scale — Sat, 13 Dec 2025 11:58:15 GMT

How to scale a database to handle 100K connections?

Too close to make it better

I Learnt — Sat, 13 Dec 2025 10:06:00 GMT

Are you too close to something to see how to make it better?

Don't fear Python subprocess or Go codegen

Ben Hoyt's technical writing — Sat, 13 Dec 2025 07:00:00 GMT

Discusses some design choices used in Jubilant: Python subprocess.run to wrap a CLI tool, a code generator to convert Go structs to Python dataclasses, and the use of uv with a simple Makefile to run commands.

Bending Emacs - Episode 8: completing-read

xenodium.com @alvaro — Sat, 13 Dec 2025 02:00:00 GMT

Nearly a couple of weeks since the last Bending Emacs episode, so here's a new episode:

Bending Emacs Episode 8: completing-read

In this video, we take a look at the humble but mighty completing-read function. We can use it to craft our purpose-built tools, whether in pure elisp or to interact with command-line utilities.

Of interest, I also highlighted the great elisp-demos package, which extends your help buffers with sample snippets.

Here are some of the completing-read snippets we played with:

Pick a queen:

(completing-read "Pick a Queen: "
                 '("Queen of Hearts ♥"
                   "Queen of Spades ♠"
                   "Queen of Clubs ♣"
                   "Queen of Diamonds ♦")
                 ;; predicate
                 nil
                 ;; require match
                 t)

Our own hashing function with an algo picker:

(defun misc/hash-region ()
  (interactive)
  (message "Hash: %s" (secure-hash (intern (completing-read
                                            "Hash type: "
                                            '(md5 sha1 sha224 sha256 sha384 sha512)))
                                   (current-buffer)
                                   (when (use-region-p)
                                     (region-beginning))
                                   (when (use-region-p)
                                     (region-end)))))

A first look at integrating completing read with a CLI util:

(completing-read "Select file: "
                 (string-split (shell-command-to-string "ls -1 ../") "\n"))

Also got creative with BluetoothConnector on macOS and completing-read.

(completing-read "Toggle BT connection: "
                 (mapcar (lambda (device)
                           ;; Extract device name
                           (nth 1 (split-string device " - ")))
                         (seq-filter
                          (lambda (line)
                            ;; Keep lines like: af-8c-3b-b1-99-af - Device name
                            (string-match-p "^[0-9a-f]\\{2\\}" line))
                          (split-string (shell-command-to-string "BluetoothConnector") "\n"))))

Some of my completing-read uses:

Emacs: quickly killing processes.
Emacs: insert and render SF symbols.
macOS open with.
macOS set default app.
macOS share (the unhinged way).
ready-player search.

Hope you enjoyed the video!

Want more videos?

Liked the video? Please let me know. Got feedback? Leave me some comments.

Please go like my video, share with others, and subscribe to my channel.

If there's enough interest, I'll continue making more videos!

Make it all sustainable

Enjoying this content or my projects? I am an indie dev. Help make it sustainable by ✨sponsoring✨

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

Dependency cooldowns, redux

ENOSUCHBLOG — Sat, 13 Dec 2025 02:00:00 GMT

Three weeks ago I wrote about how we should all be using dependency cooldowns.

Brewskis While Skiing

Navan's Archive — Sat, 13 Dec 2025 01:36:00 GMT

Just a custom page with brewskis after brewskis!

Implementing PaxosLease in Python with HTTP Flask

Bytepawn - Marton Trencseni — Sat, 13 Dec 2025 01:00:00 GMT

This article introduces PaxosLease, a simplified Paxos variant that uses expiring leases instead of persistent values to enable fast, reliable master election in distributed systems.

What's the point of lightweight code with modern computers?

Liam on Linux — Sat, 13 Dec 2025 00:38:08 GMT

I think there are many. Some examples: * The fastest code is the code you don't run. Smaller = faster, and we all want faster. Moore's law is over, Dennard scaling isn't affordable any more, smaller feature sizes are getting absurdly difficult and therefore expensive to fab. So if we want our computers to keep getting faster as we've got used to over the last 40-50 years then the only way to keep delivering that will be to start ruthlessly optimising, shrinking, finding more efficient ways to implement what we've got used to. Smaller systems are better for performance. * The smaller the code, the less there is to go wrong. Smaller doesn't just mean faster, it should mean simpler and cleaner too. Less to go wrong. Easier to debug. Wrappers and VMs and bytecodes and runtimes are bad: they make life easier but they are less efficient and make issues harder to troubleshoot. Part of the Unix philosophy is to embed the KISS principle. So that's performance and troubleshooting. We aren't done. * The less you run, the smaller the attack surface. Smaller code and less code means fewer APIs, fewer interfaces, less points of failure. Look at djb's decades-long policy of offering rewards to people who find holes in qmail or djbdns. Look at OpenBSD. We all need better more secure code. Smaller simpler systems built from fewer layers means more security, less attack surface, less to audit. Higher performance, and easier troubleshooting, and better security. There's 3 reasons. Practical examples... The Atom editor spawned an entire class of app: Electron apps, Javascript on Node, bundled with Chromium. Slack, Discord, VSCode: there are multiple apps used by tens to hundreds of millions of people now. Look at how vast they are. Balena Etcher is a, what, nearly 100 MB download to write an image to USB? Native apps like Rufus do it in a few megabytes. Smaller ones like USBimager do it in hundreds of kilobytes. A dd command in under 100 bytes. Now some of the people behind Atom wrote Zed. It's 10% of the size and 10x the speed, in part because it's a native Rust app. The COSMIC desktop looks like GNOME, works like GNOME Shell, but it's smaller and faster and more customisable because it's native Rust code. GNOME Shell is Javascript running on an embedded copy of Mozilla's Javascript runtime. Just like dotcoms wanted to dis-intermediate business, remove middlemen and distributors for faster sales, we could use disintermediation in our software. Fewer runtimes, better smarter compiled languages so we can trap more errors and have faster and safer compiled native code. Smaller, simpler, cleaner, fewer layers, less abstractions: these are all goods things which are desirable. Dennis Ritchie and Ken Thompson knew this. That's why Research Unix evolved into Plan 9, which puts way more stuff through the filesystem to remove whole types of API. Everything's in a container all the time, the filesystem abstracts the network and the GUI and more. Under 10% of the syscalls of Linux, the kernel is 5MB of source, and yet it has much of Kubernetes in there. Then they went further, replaced C too, made a simpler safer language, embedded its runtime right into the kernel, and made binaries CPU-independent, and turned the entire network-aware OS into a runtime to compete with the JVM, so it could run as a browser plugin as well as a bare-metal OS. Now we have ubiquitous virtualisation so lean into it: separate domains. If your user-facing OS only runs in a VM then it doesn't need a filesystem or hardware drivers, because it won't see hardware, only virtualised facilities, so rip all that stuff out. Your container host doesn't need to have a console or manage disks. This is what we should be doing. This is what we need to do. Hack away at the code complexity. Don't add functionality, remove it. Simplify it. Enforce standards by putting them in the kernel and removing dozens of overlapping implementations. Make codebases that are smaller and readable by humans. Leave the vast bloated stuff to commercial companies and proprietary software where nobody gets to read it except LLM bots anyway.
[Adapted from an HN comment.)

comments

The Power of Creative Destruction - Philippe Aghion Nobel laureate lecture notes

Liza Shulyayeva — Fri, 12 Dec 2025 23:01:33 GMT

Joel Mokyr, Philippe Aghion, and Peter Howitt won the 2025 Nobel Prize in Economics for their work in the theory of sustained growth through creative destruction. Today, a friend and I went to see Philippe Aghion speak about this work at Ekonomikum in Uppsala. The lectures are organized every year by the university and are open to the public, with no pre-registration. My rough notes are below [L: As usual, my own comments are embedded like this.].

I Will no Longer Program Without ChatGPT by My Side.

The Opinionated Software Architect - Medium — Fri, 12 Dec 2025 22:26:05 GMT

ChatGPT helps provide code snippets, but right now, it's much better at helping with documentation and explaining business domains.

Update: Three Years Later

I’ve gone months without actually touching the final source code. I am getting linter perfect code from my interaction with the LLM. LLMs have given me my super power.

Update: One Year Later

The title of this article should have been “I Will No Longer Program Without an LLM by My Side.” However, this sentiment remains true, and I constantly keep a ChatGPT (or another LLM) window open for continual use.

What is ChatGPT

Let’s ask chatgpt:

> What is ChatGPT?

ChatGPT is a chatbot built using the GPT-3 language model developed by OpenAI. GPT-3 stands for “Generative Pretrained Transformer 3”, and it is a state-of-the-art language processing system that can generate human-like text. ChatGPT is designed to be able to have natural, conversational interactions with users, and it can be used to create a wide range of chatbot applications.

Ok. That doesn't seem too helpful. How about this:

> Please explain to me what ChatGPT is as if I was 5.

Sure, ChatGPT is a machine learning program that can have a conversation with you. It’s like a robot friend that you can talk to, and it will try to understand what you’re saying and respond in a way that makes sense. It’s not a real person, but it can pretend to be one by using the words it knows and putting them together in a way that sounds like a conversation. You can ask it questions, and it will do its best to answer them. It’s kind of like having a really smart pen pal that you can talk to whenever you want.

Introduction

I recently found out about, or more likely finally appreciated, ChatGPT a few days ago. I will no longer code without a window open to ChatGPT by my side.

At first, you might think it is because of ChatGPT’s ability to help with coding. And it is helpful for that. I program primarily in SQL and use ChatGPT to help with coding in SQL.

However, I find immense value in ChatGPT in helping understand a business domain and documentation within that domain.

ChatGPT is amazing at providing easy-to-understand definitions of anything I've thrown at it.

The Difficult Part of Programming

It is often said that one of the two hard things about programming is naming things. Documenting the code before writing it often helps with naming a thing like a function or variable. Writing documentation is especially useful in understanding the domain.

One of the reasons why automated programming, and visual programming being one of those, is so tricky isn't because of the coding. It is understanding the business domain and describing it correctly in source code. This is also why it is sometimes hard to understand other people's source code. You may have coding expertise but need more domain expertise.

Good documentation and business domain understanding help with coding, including coming up with good names for things.

An Example of Good Documentation for a Business Domain

I'm currently working on Tracking Madness, a tool to help marketing with multi-touch attribution. I'm very new to the domain and have had to ask a lot of questions within this domain.

One of the features of the product is to collect and store marketing campaign information from multiple sources. For this purpose, we created the following table:

CREATE TABLE IF NOT EXISTS marketing.campaign (
  campaign_id uuid NOT NULL DEFAULT uuid_generate_v1(),
  platform_persona_id uuid REFERENCES persona.persona(persona_id),
  campaign_label lib.label NOT NULL,
  campaign_description lib.description NOT NULL DEFAULT '',
  tag_ids tag.ltreelower[] NOT NULL
    CONSTRAINT tag_id_must_be_valid_tags
      CHECK ( tag.check_tag_array(
        tag_ids, '', 'marketing.campaign', 'tag_ids'
      )) DEFAULT '{}',

  CONSTRAINT marketing_campaign_id_pk PRIMARY KEY (campaign_id)
);

And we had the following documentation for that table (which could have been more helpful).

COMMENT ON TABLE marketing.campaign IS 'A sales and marketing campaign.';

Ya. That isn't useful at all. ChatGPT comes to the rescue. They can provide a great explanation of a marketing campaign and write the documentation faster than I could.

> What is a marketing campaign?

A marketing campaign is a coordinated series of marketing efforts designed to achieve a specific business objective. Marketing campaigns can take many different forms, including advertising campaigns, public relations campaigns, social media campaigns, and email marketing campaigns.

My new documentation is now:

COMMENT ON TABLE marketing.campaign IS
'A (marketing) campaign is a coordinated series of marketing
 efforts designed to achieve a specific business objective.
 Marketing campaigns can take many different forms, including
advertising campaigns, public relations campaigns, social media
campaigns, and email marketing campaigns.';

Another Example: Documentation and Tags

I have a single table for all SQL lookups and tagging; see the hierarchical tags repository for details.

A tag can have a description, and writing descriptions for each tag is time-consuming. For example, I needed to provide tags for an ad's style. I didn’t even know what styles of ads there could be. I’ve tried using tools like Google to find information about a domain. It’s possible to do so, but time-consuming.

> What are some traits of a marketing ad?

An advertisement is a marketing communication that is designed to promote or sell a product, service, or idea. Some common properties of an advertisement include:

* Target audience: An advertisement typically targets a specific group of people, based on factors such as their age, gender, interests, or other demographic characteristics.

* Message: An advertisement typically has a clear and concise message that communicates the value or benefits of the product, service, or idea being promoted.

* Format: An advertisement can take many different forms, such as a print ad in a magazine, a TV commercial, a radio spot, a banner ad on a website, or a sponsored post on social media.

* Call to action: An advertisement often includes a call to action, which is a specific instruction to the target audience that encourages them to take a desired action, such as visiting a website, calling a phone number, or making a purchase.

* Branding: An advertisement typically includes branding elements, such as a logo, tagline, or other visual or verbal elements that are associated with the advertiser’s brand. This helps to create brand awareness and recognition among the target audience.

* Marketing objectives: An advertisement typically has specific marketing objectives, such as increasing sales, building brand awareness, or generating leads. The success of an advertisement is often measured by how well it achieves these objectives.

These are just a few examples of the properties of an advertisement. There may be other properties that are specific to a particular type of advertisement or a specific advertising campaign.

This list wasn’t exhaustive, so I asked if I could get more examples, and ChatGPT gave more examples. The above results were used to pre-populate the tag table.

Conclusion

One time-consuming aspect of programming is understanding the business domain and documenting that domain in code where needed.

I’ve found that ChatGPT has increased my productivity in this area by at least threefold. I will always write code with ChatGPT by my side simply for their ability to explain something clearly.

I Will no Longer Program Without ChatGPT by My Side. was originally published in The Opinionated Software Architect on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Machrihanish Golf Club

Wigs on the Green — Fri, 12 Dec 2025 18:02:48 GMT

An exceptional links

SQLite for a REST API Database?

matduggan.com — Fri, 12 Dec 2025 16:19:00 GMT

Spoiler: it worked fine.

Aiming for the second time

I Learnt — Fri, 12 Dec 2025 10:33:00 GMT

I was chatting to a colleague and he mentioned how he had written some code and expected it to work first time and was surprised when it didn’t.

Programming isn't the job

Nicola Iarocci — Fri, 12 Dec 2025 09:22:18 GMT

AI can replace most of programming, but programming isn’t the job. Programming is a task. It’s one of many things you do as part of your work. But if you’re a software engineer, your actual job is more than typing code into an editor. The mistake people make is conflating the task with the role.

It’s like saying calculators replaced accountants. Calculators automated arithmetic, but arithmetic was never the job. The job was understanding financials, advising clients, making judgment calls, etc. The calculator just made accountants faster at the mechanical part. AI is doing something similar for us.

Favourite Fonts For 2025

tasuki’s blog — Fri, 12 Dec 2025 02:00:00 GMT

I enjoy obsessing about typefaces. They’re everywhere, yet often somewhat invisible. I like free things, not just because they’re free (as in beer), but also because they can’t easily be taken away (as in freedom).

I'm moving to Berlin

Nemo's Home — Fri, 12 Dec 2025 02:00:00 GMT

Haven’t posted here in a while, but this is worth an update: I’m moving to Berlin. I’ve loved living in Bangalore for the last decade (I moved here just after the first HillHacks in May 2015), but it is time for an adventure.

For the last couple of years, I’ve spent my time living in Indiranagar, building communities, helping underline.center, working on blr.today, organizing events, and really doing things that I care about. It has been a wonderful time, but we wanted to experience life elsewhere, and Berlin seems to fit the bill.

Bangalore’s infrastructure has been in the news, and it is a part of why I’m moving. An unwalkable footpath on CMH road meant we spent half a year dealing with a broken elbow this year. At Takshashila, I was taught that I’m not allowed to bring up civic problems without also coming up with solutions. But Bangalore is an unsolvable paradox: A city with 50+ unicorns and no walkable footpaths.

I’ve fought my personal share of battles against the state, but this is one where I don’t have any hope of making a difference. I appreciate the work that the Bangalore Civil Society is doing in attempting to hold the missing-government accountable - it just isn’t the kind of work that I want to do. Fighting for basic necessities (clean air, walkable footpaths, open public spaces, well-funded public transit) shouldn't be anyone's job in a city as large as Bangalore. I’m picking Exit (for now).

Why Berlin? Mainly because I have lots of friends there. Our immigration journey is still quite early, so maybe I can write about it when things have stabilized a bit. For now, if you have any Berlin recommendations or connections, please send them my way.

Goals for 2026

Chris' Full Stack Blog RSS Feed — Fri, 12 Dec 2025 02:00:00 GMT

There's a new blog post "Goals for 2026" and you can read it online.
undefined
You can also subscribe for weekly emails on my latest posts - if I publish anything that week!

Filozofie moderního internetu RELOADED

Kubíkovo — Fri, 12 Dec 2025 01:00:00 GMT

Dodatky prezentace Filozofie moderního internetu z přednáškové noci Brnoc 2025

Gothenburg and biohacking and worms and...

Liza Shulyayeva — Thu, 11 Dec 2025 23:01:33 GMT

I’ve been in a kind of hyper-busy mode before Christmas. Mostly that has translated into work, but there are also quite a few other things happening.

Buncefield

I Learnt — Thu, 11 Dec 2025 15:21:00 GMT

20 years ago on the 11th December 2005 I had just got up and was walking down our hallway when there was a massive explosion and it literally felt like the whole roof had been lifted off and landed back down again. The heavy wooden loft door was blown open and we later found it had buckled our patio doors.

The Studio: Season 1

🦉 olshansky 🦁 — Thu, 11 Dec 2025 07:35:09 GMT

This show is the embodiment of Seth Rogan in a fancy suit.

Funny. Witty. Original. Stylish. Just the right amount of cringe to keep you entertained without drifting into self-parody.

Rogan keeps showing up everywhere lately as actor, director, producer, writer. This show is a prime example of what time, experience, age, and a touch of talent can compound into ;)

The show gives you a peek into how Hollywood works, but it also feels like a tour of what Rogan loves and hates about the industry told through satire.

GitHub Actions for Pulumi with an AWS S3 Backend

Nelson Figueroa — Thu, 11 Dec 2025 02:00:00 GMT

How to set up GitHub Actions for Pulumi when the state is stored in an AWS S3 Bucket.

Plans for December

Jason O'Neil — Thu, 11 Dec 2025 01:54:07 GMT

“I had all these plans for December to be different this year.” Most Decembers recently have felt busy. The end of the year events, the end-of-school celebrations and gifts for teachers, the pressure to finish work for the year strongly, the preparation for Christmas and for holidays, the gifts and the parties. And somewhere in […]

More app recommendations

Gonçalo Valério — Wed, 10 Dec 2025 21:35:08 GMT

The good part of having a personal blog is that I can write about whatever comes to my mind. Today I was thinking of how people find the software they use, how many people end up using the same apps because they don’t know any alternatives, and the fact that many creators (especially open-source ones) […]

TypeScript scripts as DuckDB Table Functions

tobilg.com — Wed, 10 Dec 2025 19:07:28 GMT

What if you could query any REST API, GraphQL endpoint, or web page directly from DuckDB using SQL? No ETL pipelines, no intermediate files, no complex setup just write a TypeSc...

Hacking Angular Signals

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:47:05 GMT

“Serpents II”, Gustav Klimt, 1907

Let’s check out what Angular Signals have under the hood, and how we can use it for extending their functionality and debugging.

What are Angular Signals

Angular Signals are functions with methods:

const $val = signal(0);

// function:
const value = $val();

// object:
$val.set(4);
$val.update((v) => v * 2);

How is this possible? Because in JavaScript, functions are objects:

// declaring a function
const double = (val: number) => val * 2;

// adding a method
double.isEven = (number: number) => number % 2 === 0;

// use as object
double.isEven(15) // false

// use as function
double(8) // 16

How can we use it?

We can:

add new methods;
override methods set() and update() to intercept modifications;
read internal state variables and methods of signal;
create a proxy signal that will intercept reads.

Extending our Signals

Sometimes you need a variable to be a Signal, but some parts of your code would like to use it as an Observable instead.

Fortunately, interfaces of Signals and Observables have no collisions in method names. So let’s create a hybrid:

export function toObservableSignal<T>(
  s: Signal<T>, 
  options?: ToObservableOptions
) {
  if (isDevMode() && !options?.injector) {
    assertInInjectionContext(toObservableSignal);
  }

  // create an observable
  const obs = toObservable(s, options);
  
  // add methods of observable to our signal object
  for (const obsKey in obs) {
    (s as any)[obsKey] = (obs as any)[obsKey];
  }
  return s;
}

Here we are simply adding new methods to the existing object.

Or, we could create a Proxy object and only return methods of an Observable, when our Signal doesn’t have the requested method:

export function toObservableSignal<T>(s: Signal<T>) {

  const obs = toObservable(s, options); 
   
  return new Proxy(s, {
    get(_, prop) {
      if (prop in s) {
        return (s as any)[prop];
      }
      return (obs as any)[prop];
    }
  });
}

Usage example:

@Component({
  //...
  template: `
    <h4>Signal A: {{ a() }}</h4>
    <h4>Observable A: {{a|async}}</h4>
    <h4>Signal C (computed() A*3): {{c()}}</h4>

    {{quote()}}
  `,
})
export class App {
  a = toObservableSignal(signal<number>(1));

  // use as Observable
  b = this.a.pipe(
    debounceTime(500),
    distinctUntilChanged(),
    switchMap((v) => this.http.get('https://dummyjson.com/quotes/' + v))
  );

  // use as Signal
  c = computed(() => this.a() * 3);

  quote = toSignal(this.b);

  increment() {
    // "a" will not stop being a Signal after 
    // we used it as an Observable
    this.a.update((v) => v + 1);
  }

  decrement() {
    this.a.update((v) => Math.max(1, v - 1));
  }
}

https://medium.com/media/b706a844f4f00da584f8edc76d1d1d1f/href

You can find this function in the NG Extension Platform: documentation.

You can extend Signals with any functions you want, your fantasy here has almost no limitations: just don’t use names set, update, and asReadonly.

Overriding existing methods

Let’s say that we want to intercept writes to our Signal to transform input values, duplicate information somewhere else, or just for debugging.

function skipNonEvenNumbers(s: WritableSignal<number>) {
  const srcSet = s.set; // we need the source method to avoid recursion

  s.set = (value: number) => {
    if (value % 2 !== 0) {
      console.warn('[set] skipping:', value);
      return;
    }
    console.log('[set]:', value);
    srcSet(value);
  };
  s.update = (updateFn: (value: number) => number) => {
    const value = updateFn(s());
    if (value % 2 !== 0) {
      console.warn('[update] skipping:', value);
      return;
    }
    console.log('[update]:', value);
    srcSet(value);
  };
}

Usage example:

https://medium.com/media/7197f67c8e21efbd396757f61737041a/href

This trick is being used in Reactive Storage: getWritableSignal().

Inside a Signal

Angular Signal is not just a function, it is an object. This object has a hidden field, SIGNAL, which contains some interesting data and functions. I’m glad we have it, and I hope you will not abuse it. Because the tricks above were “a little bit hacky”, and the tricks below are too filthy to use for anything but debugging, creating dev tools, and fun.

Every Angular Signal extends ReactiveNode:

// packages/core/primitives/signals/src/graph.ts

export const REACTIVE_NODE: ReactiveNode = {
  version: 0 as Version,
  lastCleanEpoch: 0 as Version,
  dirty: false,
  producerNode: undefined,
  producerLastReadVersion: undefined,
  producerIndexOfThis: undefined,
  nextProducerIndex: 0,
  liveConsumerNode: undefined,
  liveConsumerIndexOfThis: undefined,
  consumerAllowSignalWrites: false,
  consumerIsAlwaysLive: false,
  producerMustRecompute: () => false,
  producerRecomputeValue: () => {},
  consumerMarkedDirty: () => {},
  consumerOnSignalRead: () => {},
};

this way:

// packages/core/primitives/signals/src/signal.ts

export const SIGNAL_NODE = {
  ...REACTIVE_NODE,
  equal: defaultEquals,
  value: undefined,
}

But an instantiated Signal object does not contain all of this directly. All of them are hidden under the field that uses a Symbol as a name:

// packages/core/primitives/signals/src/signal.ts

export function createSignal<T>(initialValue: T): SignalGetter<T> {
  const node: SignalNode<T> = Object.create(SIGNAL_NODE);
  node.value = initialValue;
  const getter = (() => {
                   producerAccessed(node);
                   return node.value;
                 }) as SignalGetter<T>;

  // next line adds a SignalNode to the field SIGNAL:
  (getter as any)[SIGNAL] = node;
  return getter;
}

So if you have a signal $value and you access SIGNAL field, then you’ll get all of the fields that SIGNAL_NODE has.

How can we use it?

We can read fields and override methods to intercept access and use it for debugging or to create fancy tools that illustrate what is going on inside a Signal and render the Dependency Graph.

We can even convert some fields to accessors:

function getSignalVersion<T>(s: WritableSignal<T>): Signal<number> {
  const node = s[SIGNAL];
  const $version = signal(0);

  Object.defineProperty(node, 'version', {
    get: () => {
      const v = untracked($version);
      console.log('🟢 reading:', v);
      return v;
    },
    set: (v) => {
      untracked(() => $version.set(v));
      console.log('🔴 writing:', v);
    },
  });

  return $version.asReadonly();
}

StackBlitz:

https://medium.com/media/01c5c1f62e9a26723cb00f6b3a9370bb/href

Or create a proxy that can watch Signal reads without effect():

function watchSignalReads<T, M extends Signal<T> | WritableSignal<T>>(s: M): M {
  const node = s[SIGNAL];
  const newGetter = () => {
    const value = s();
    console.log('Read:', value);
    return value;
  };
  (newGetter as any)[SIGNAL] = node;
  if (s.hasOwnProperty('set')) {
    const w = s as WritableSignal<T>;
    newGetter.set = w.set;
    newGetter.update = w.update;
    newGetter.asReadonly = w.asReadonly;
  }

  return newGetter as M;
}

Usage example:

https://medium.com/media/dfd976f5d8ba597f9ab5a5d27adad862/href

Again, I hope you won’t even consider using this in “production,” and instead, I hope you’ll utilize it to create some amazing tools, gain recognition, and contribute to enriching the Angular ecosystem 😎

Preparing our Code for Zoneless Angular

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:46:48 GMT

“Le Pont Neuf Paris”, Pierre-Auguste Renoir, 1872

This article explains how to modify your code to make your library or app work without Zone.js.

What is Zoneless Angular?

In the article “Angular Change Detection — Today and Tomorrow”, I’ve explained how different types of change detection work in Angular.

The main benefit of making Angular apps zoneless is performance. No more unnecessary CD cycles and recomputations of values. No more checking every binding on every mousemove event. No more runOutsideAngular() calls to reduce the amount of CD cycles, no more juggling with detach() and detectChanges().

Another benefit: we can safely use async..await syntax because we don’t rely anymore on monkey-patching Promises by Zone.js.

Removing Zone.js dependency also removes the “Angular-compatible” term for JS tools: you don’t need to worry anymore if changes that some JS tool makes will be caught by Angular’s Change Detection and rendered correctly.

Prerequisites

Before your app goes zoneless, it should be “OnPush compatible”. It means, that every binding in your template is reactive.

Reactive bindings will notify Angular that their value has changed, so the DOM might need to be modified.

Examples of non-reactive bindings:

@Component({
  template: `
   <div> {{ name }} </div>
   <child [value]="value"/>
`
})
export class ExampleComponent {
   name = "Alice";
   value = "Bob";
}

The bindings {{ name }} and [value]=”value” lack reactivity — they won’t update if the values of name or value are modified because the template cannot know about it.

Reactive bindings:

@Component({
  template: `
   <div> {{ name() }} </div>
   <child [value]="value | async"/>
`
})
export class ExampleComponent {
   name = signal("Alice");
   value = new BehaviorSubject("Bob");
}

Here, the template will get a notification when name or value are updated. What happens in the template (what is marked as dirty, what is marked for traversal) — just implementation details, it doesn’t matter. What matters is: when notified about the changes, Angular knows what part of the views tree it should update.

There are only two requirements:

Every binding in your templates should be reactive;
Angular v17.1+.

No other things are required. If all components in your app have changeDetection: ChangeDetectionStrategy.OnPush then your app will work fine in “zoneless” mode. There are many new things in the latest releases of Angular, but they are not required to be used to make your app zoneless.

Preparing your code

NgZone has a few methods that your app or library may use:

onMicrotaskEmpty();
onStable();
onUnstable();
onError();
run(), runOutsideAngular(), runGuarded(), runTask().

run*() methods are not needed in Zoneless Angular: you can just call your function directly.

Was:

@Injectable()
export class ExampleService {
  private ngZone = inject(NgZone);
  
  draw() {
    this.ngZone.runOutsideAngular(() => this.putPointsToCanvas());
  }

  private putPointsToCanvas() {}
}

Now:

@Injectable()
export class ExampleService {
  draw() {
    this.putPointsToCanvas();
  }

  private putPointsToCanvas() {}
}

To replace onStable() and onMicrotaskEmpty(), you can use afterRender() or afterNextRender().

afterRender() will be called after every rendering of the application (not some component), and afterNextRender() will be called after the next rendering event, once. Notice that both of them have phases (second argument).

Was:

@Injectable()
export class ExampleService {
  private ngZone = inject(NgZone);
  
  draw(): Observable<string> {
    this.ngZone.onStable().pipe(
      tap(() => this.putPointsToCanvas())
    );
  }

  private putPointsToCanvas() {}
}

Now:

@Injectable()
export class ExampleService {
  private readonly afterNextRender$ = new Subject();
  
  constructor() {
    afterNextRender(() => this.afterNextRender$.next({}));
  }
  
  draw(): Observable<string> {
    this.afterNextRender$.pipe(
      tap(() => this.putPointsToCanvas())
    );
  }

  private putPointsToCanvas() {}
}

This code will work both in Zoneless and “regular” Angular.

Notice that you can use afterRender() and afterNextRender() whenever you want; just call them in an injection context. Because, as the documentation says: “The execution of render callbacks is not tied to any specific component instance, but instead an application-wide hook”.

StackBlitz example:

https://medium.com/media/40a5362440a5fce76333e0c3458508ed/href

Third-party libraries

The main purpose of this article is to help library maintainers in preparing their code for Zoneless Angular. But sometimes we use a library that is too large to fork, and we need to make it work in our application right now.

For libraries that are not updated yet and use onStable() or onMicrotaskEmpty(), we can emulate the behavior of onStable() and onMicrotaskEmpty(), and later remove all of these emulations when all the libraries we use are ready for Zoneless Angular (or if and when Angular provides its own emulation).

I’ve created a helper with functions that override the NoopNgZone implementation and emulate the onStable() behavior: GitHub link. I don’t publish it as a library because it is a temporary solution.

I’ll repeat this because it is important: please update your apps and libraries to not rely on NgZone interface (see above how to modify your code). Do not make your code rely on emulations made by this code snippet. Only use it to temporarily workaround limitations of the libraries you cannot modify.

Let me explain how this emulation works:

export class NoopNgZone implements NgZone {
  // ...

  private readonly onStableEmitter = new EventEmitter<any>();
  private readonly schedule = getCallbackScheduler();

  get onStable() {
    this.schedule(() => this.onStableEmitter.emit({}));
    return this.onStableEmitter;
  }
  
  // ...
}

When code calls NgZone.onStable(), our getter returns an Observable. Before returning it, we schedule an emission of the new value (which would mean that the zone is “stable”).

For scheduling, I use awesome code I found in the Angular source code.

Sometimes, libraries are so tightly bound to Zone.js that they expect onStable() or onMicrotaskEmpty() to emit quite often. For them, one event that we emit is not enough.

To make them work, you can find an event after which that library wants to do its job and artificially emit onStable() or onMicrotaskEmpty() when this event happens:

export class ExampleComponent {
  private readonly ngZoneNoop = inject(NgZone) as NoopNgZone;
  private readonly docClickHandler = () => this.ngZoneNoop.emitOnStable();

  constructor() {
    document.addEventListener('click', this.docClickHandler);
  }

  ngOnDestroy() {
    document.removeEventListener('click', this.docClickHandler);
  }
}

In the example above, we are listening for click events and making our NgZone implementation emit onStable event on every click.

I hope you will never need to use a workaround like this, and all the libraries will quickly adapt to Zoneless Angular.

Converting our Angular app to zoneless

This part is pretty easy:

Provide a custom NgZone implementation and a scheduler:

import { provideExperimentalZonelessChangeDetection } from '@angular/core';

bootstrapApplication(AppComponent, {
  providers: [
    provideExperimentalZonelessChangeDetection(),
  ]
});

2. Remove the import of zone.js in your polyfills.ts file, or (if you don’t have this file), remove the “zone.js” line from the polyfills array in the angular.json file.

That’s it!

You can see that it doesn’t require a lot of changes if your app or lib is already “OnPush-compatible”.

Authors of libraries, please consider making your code compatible with Zoneless Angular. It will not take a lot of effort: afterRender() here, afterNextRender() there and that’s it 😉

The Angular Team needs your feedback, they want to know about the cases that don’t work and where afterRender() is not good enough. Let’s start preparing our codebases and provide them feedback!

I extend my heartfelt gratitude to the reviewers whose insightful comments and constructive feedback greatly contributed to the refinement of this article:

Angular Signals, Reactive Context, and Dynamic Dependency Tracking

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:46:31 GMT

“The Ball”, Félix Vallotton, 1899

To effectively use Angular Signals, it’s crucial to understand the concept of the “reactive context” and how dependency tracking works. In this article, I’ll explain both these things, and show how to avoid some related bugs.

Dependency Tracking

When you use Angular Signals, you don’t need to worry about subscribing and unsubscribing. To understand how it works, we’ll need a few terms:

Dependency Graph: graph of nodes, every node implements ReactiveNode interface;
Producers: nodes that contain values and notify about new values (they “produce reactivity”);
Consumers: nodes that read produced values (they “consume reactivity”);

Signals are producers, computed() is producer and consumer simultaneously, effect() is consumer, templates are consumers.

You can read a more detailed article about the Dependency Graph in Angular Signals (with animated graph example).

How automatic dependency tracking works: there is a variable, global for all the reactive nodes, activeConsumer, and every time computed() runs its computation function, every time effect() runs its side-effects function, or a template is being checked for changes, they:

Read the value of activeConsumer (to remember the previous consumer);
Register themselves as a activeConsumer;
Run the function or execute a template (some signals might be read during this step);
Register the previous consumer (from Step 1) as an activeConsumer.

When any producer is read, it retrieves the value of activeConsumer and includes this active consumer in the list of consumers dependent on the signal. When a signal is updated, it subsequently sends a notification to every consumer from its list.

Let’s examine what happens step by step in this example:

@Component({
  template: `
   Items count: {{ $items().length }}
   Active items count: {{ $activeItemsCount() }}
`   
})
class ExampleComponent {
  protected readonly $items = signal([{id: 1, $isActive: signal(true) }]);

  protected readonly $activeItemsCount = computed(() => {
    return this.getActiveItems().length;
  });

  private getActiveItems() {
    return this.$items().filter(i => i.$isActive());
  }
}

The template reads the value of activeConsumer and saves it to the prevConsumer variable (this variable is local to the template);
The template sets itself as activeConsumer;
It calls $items() signal to get a value;
$items signal retrieves the value of activeConsumer;
The received value is not empty (it contains a link to the template), so $items signal puts this value (link to our template) into the list of consumers. After that, every time $items is updated, the template will be notified — a new link has been created in the dependency graph;
$items returns a value to the template;
The template reads the value of $activeItemsCount signal. To return a value, $activeItemsCount needs to run its computation function (the function we pass in our code to computed();
Before running the computation function, $activeItemsCount reads the value of activeConsumer and saves it to its local variable prevConsumer. Because $activeItemsCount is also a consumer, it puts a link to itself to the activeConsumer variable;
Computation function calls getActiveItems() function;
Inside this function, we read the value of $items — steps from 3 to 6 are repeated, but because our template is already dependent on $items, Step 5 will not add a new consumer to the list;
When the value (an array of items) is returned, getActiveItems() reads every element of this array and reads the value of $isActive();
$isActive is a signal. So, before it returns a value, it repeats steps 3–6. During step 4, $isActive retrieves the value of activeConsumer. At this moment activeConsumer contains a link to $activeItemsCount, so at step 5 $isActive (each one from the array) will add $activeItemsCount to the list of dependent consumers. Any time $isActive is updated, $activeItemsCount will be notified, $activeItemsCount will notify our template that its value is stale and needs to be recomputed. After that, our template eventually (not right after the notification) will ask $activeItemsCount what is the new value, and steps from 7 to 14 will be repeated;
getActiveItems() returns a value. $activeItemsCount uses this value for computation and before returning it, it puts the value of its local variable prevConsumer to the activeConsumer variable;
$activeItemsCount returns a value;
The template puts the previously saved value of prevConsumer to activeConsumer.

It is not a short list, but please read it thoroughly.

The most important thing here is: that consumers (computed(), effect(), templates) don’t need to worry about adding signals they read to the list of dependencies. Signals will do it themselves, using the activeConsumer variable. This variable is accessible to any reactive node, so it doesn’t matter how deep in the functions chain some signal will be read — any signal will get the value of activeConsumer and add it to the list of consumers.

Remember: if you call a function in a template, computed() or effect() (a consumer), and that function reads another function and that function reads another function…, and finally, at some level, a function reads a signal, and that signal adds that consumer to its list and will notify it about the updates.

Debugging-like reading can be tedious, so let me entertain you with this small app:

https://medium.com/media/00e53618d5af774783c6a72cea5a5164/href

Please do the following in that app:

Click button “2” to make it active, then click it again. Notice that the “Active items” text above the buttons reflects the change;
Click the “Add Item” button;
Click button “4”. Notice that “Active items” doesn’t reflect the change;
Click button “2”;
Now click button “4” a few times and notice that the “Active items” text reflects it as expected.

But why? Let’s check the code:

export type Item = {
  id: number;
  $isActive: WritableSignal<boolean>;
};

@Component({
  selector: 'my-app',
  template: `
    <div>Active items: {{ $activeItems() }}</div>
    <div>
      <span>Click to to toggle:</span>
      @for(item of items; track item.id) {
        <button (click)="item.$isActive.set(!item.$isActive())" 
                [class.active]="item.$isActive()">
          {{ item.id }}
       </button>
      }
    </div>
    <div>
      <button (click)="addItem()">Add Item</button>
    </div>
  `,
})
export class App {
  protected readonly items: Item[] = [
    { id: 1, $isActive: signal(true) },
    { id: 2, $isActive: signal(false) },
    { id: 3, $isActive: signal(true) },
  ];

  protected readonly $activeItems = computed(() => {
    const ids = [];
    for (const item of this.items) {
      if (item.$isActive()) {
        ids.push(item.id);
      }
    }
    return ids.join(', ');
  });

  protected addItem() {
    this.items.push({
      id: this.items.length + 1,
      $isActive: signal(false),
    });
  }
}

Now let’s analyze why the “Active items” line is not updated correctly.

Binding in our template:

<div>Active items: {{ $activeItems() }}</div>

$activeItems is a signal, provided by computed():

protected readonly $activeItems = computed(() => {
  const ids = [];
  for (const item of this.items) {
    if (item.$isActive()) {
      ids.push(item.id);
    }
  }
  return ids.join(', ');
});

The function we pass to computed() will be re-executed every time any of the signals it reads is updated. What signals do we read there?

It’s $isActive signal of every item in the this.items array.

Notice how the $ sign in the name of the variable helps quickly find the sources of reactivity. This principle applies similarly to the effect() function and component templates. That’s why I use it, but it’s simply a matter of personal preference.

So why $activeItems was not updated after steps 2 and 3?

The computation function will only be re-executed when one of the signals it depends on is updated.

When we click “Add Item”, we modify this.items and create a new signal inside the new item. But before this moment, our computed() function had never read that signal, so it does not have it in the list of dependencies.

Before and after clicking “Add Item,” the list of signals that $activeItems depends on remains unchanged: three $isActive signals from the three items in this.items.

Because none of these signals is modified when we click “Add Item”, computed() will not be notified and the computation function will not be re-executed.

We can toggle our new item in the list of buttons as many times as we want, but only the signals of the 3 first items will notify $activeItems and it will re-execute the function we sent.

But if we re-execute our computation function, it will read all the items from this.items again and will read the new signal, finally. The new signal will become the new dependency of the $activeItems node, and it will be notified every time one of them is changed.

To do this, we need to modify one of the existing dependencies: that’s why we click button “2” in step 4.

This example is created to remind you, that functions we pass to computed() and effect() will only be re-executed, when one of the producers they read is updated.

This is why it is always useful to double-check, what dependencies your computed() has and what of them should cause a re-computation. If some of them should not — use untracked().

Some of the functions we pass to computed() or effect() might read signals (or functions they call might read signals).

this.$petWalkingIsAllowed = computed(() => {
  return this.$isFreeTime() && this.isItGoodWeatherOutside();
});

isItGoodWeatherOutside() {
  return $isSunny() && $isWarm() && !$isStormy();
}

To understand if we should wrap such calls with untracked() to avoid non-desired recomputations, we can use this logic:

If we don’t want our computed() to compute a new result when that function (isItGoodWeatherOutside()) returns a new value, then wrap it with untracked():

this.$petWalkingIsAllowed = computed(() => {
  return this.$isFreeTime() && untracked(() => this.isItGoodWeatherOutside());
});

isItGoodWeatherOutside() {
  return $isSunny() && $isWarm() && !$isStormy();
}

If on every new value from that function we do want to re-run our computation, do not wrap it with untracked().

As you can see, untracked() helps us control which dependencies we want to track. It also helps to manage another important aspect:

Reactive Context

Above, in “How automatic dependency tracking works,” I’ve mentioned the variable activeConsumer.

When activeConsumer is not null, signals we read will add that activeConsumer to the list of consumers, to later notify members of this list about modifications of a signal. If a reactive node is read while activeConsumer is empty, it will not create any new link in the reactive nodes dependency graph.

In other words, while activeConsumer is set, we are reading signals within the Reactive Context.

In the majority of cases, the reactive context will be handled automatically, and only the intended links and dependencies will be created and removed.

But sometimes we unintentionally leak the reactive context.

Let’s try out this app:

https://medium.com/media/27323da5b59136548e2554b27ec4a062/href

If you try to use it, you’ll notice that:

clicking “Add Item” leads to a complete reset of all statuses;
clicking to toggle the status changes it randomly, affecting more than just one button.

Can you quickly spot the bug?

@Component({
  template: `
    <div>Active items: {{ $activeItems() }}</div>
    <div class="flex-row">
      <span>Click to to toggle:</span>
      @for(item of $items(); track item.id) {
      <button (click)="item.$isActive.set(!item.$isActive())" [class.active]="item.$isActive()" [style.transform]="'scale('+item.$scale()+')'">
        {{ item.id }}
      </button>
      }
    </div>
    <div>
      <button (click)="addItem()">Add Item</button>
    </div>
  `,
})
export class App {
  private readonly $itemsCount = signal(3);

  protected readonly $items: Signal<Item[]> = computed(() => {
    console.warn('Generating items!');
   
    const items: Item[] = [];
    for (let id = 0; id < this.$itemsCount(); id++) {
      const $isActive = signal(Math.random() > 0.5);
      const $scale = signal($isActive() ? 1.2 : 1);
      items.push({ id, $isActive, $scale });
    }
    return items;
  });

  protected readonly $activeItems = computed(() => {
    const ids = [];
    for (const item of this.$items()) {
      if (item.$isActive()) {
        ids.push(item.id);
      }
    }
    return ids.join(', ');
  });

  protected addItem() {
    this.$itemsCount.update(c => c + 1);
  }
}

What can we see here:

We render the list of items from $items, which is computed();
$items generates a new array of items, and their count is controlled by the $itemsCount signal. Every time we modify $itemsCount, items are regenerated;
addItem() simply increments $itemsCount, triggering recomputation of $items.

Now we can see why “Add Item” works this way. Let’s try to figure out why the status toggling behaves strangely.

If we open the console, we’ll notice that every time we click a button, a “Generating items!” warning is logged. But why? We’re not modifying $itemsCount, so why is $items recomputed?

Perhaps you’ve already noticed that the computation function of $items reads one more source of reactivity: the signal $isActive:

const $scale = signal($isActive() ? 1.2 : 1);

This signal ($isActive) is being read in the reactive context: activeConsumer contains $items, so $isActive will notify $items about every change. Therefore, when we modify $isActive in an attempt to toggle this status, we trigger recomputation of $items.

There are multiple ways to fix this bug, but this approach prevents the leakage of the reactive context:

const $scale = signal(untracked($isActive) ? 1.2 : 1);

What does untracked() do?

/** 
 * https://github.com/angular/angular/blob/75a186e321cb417685b2f13e9961906fc0aed36c/packages/core/src/render3/reactivity/untracked.ts#L15
 *
 * packages/core/src/render3/reactivity/untracked.ts
 *
 **/
export function untracked<T>(nonReactiveReadsFn: () => T): T {
  const prevConsumer = setActiveConsumer(null);
  try {
    return nonReactiveReadsFn();
  } finally {
    setActiveConsumer(prevConsumer);
  }
}

sets activeConsumer to null and saves the returned value to the local variable prevConsumer;
runs the given function;
restores activeConsumer from prevConsumer.

It temporarily disables the reactive context, executes our function, and then restores the reactive context.

Because of that, while our function is being executed, if any signals are being read, they will read null from activeConsumer and won’t add it to their lists of consumers. In other words, no new dependencies will be created.

In this example, we have some “hints” in the console, and our code is very small and simple. In real apps, signal reading might be buried deep within the function call chain, and the code could be much larger and more complex. Bugs like this can be challenging to debug in real apps, which is why I recommend preventing them by using untracked() whenever you don't want to leak the reactive context.

There are quite interesting and unexpected ways to leak the reactive context:

Creating an instance of a class that reads some signals;
Calling a function that calls another function, which reads a signal;
Creating a component inside effect();
Emitting a new value to an observable.

When you use computed() and effect(),

Read other signals with caution — they’ll rerun the entire function every time they change, triggered by any other function.
Make these functions easy to read and understand;
Double-check every source of reactivity that your function consumes.

As is often the case, implicit dependency tracking brings not only benefits but also some trade-offs. But when used with skill and caution, you can build wonderful apps with Angular Signals!

I extend my heartfelt gratitude to the reviewers whose insightful comments and constructive feedback greatly contributed to the refinement of this article:

Angular Inputs and Single Source of Truth

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:46:13 GMT

“Two Cypresses”, Paul Signac, 1893

The main way for Angular components to receive external data is through “inputs.” In this article, I’ll explain why the Single Source of Truth principle should be applied to inputs.

Wikipedia provides a scientific description of the Single Source of Truth, but if we apply it to Angular components and their inputs, it will sound like this:

Inputs of a component should only be modified from outside the component.

This simple rule can save your code from very weird bugs. Let’s explore the simplest case:

https://medium.com/media/5a57e455950a955b48b5ecdfa6d2bec9/href

In this small demo (source code), you can add items to your shopping cart, but after 10 seconds, the list will be replaced with some items you didn’t pick.

This demo emulates a situation where the shopping cart data is loaded from the server, but while the request was loading, the user was able to add some items to the cart. Maybe it’s not the best demo, but I hope it illustrates the idea. Creating code with bugs intentionally is not as easy as it happens unintentionally 😉

Generally speaking, the state of our component is globally mutable. We should avoid it everywhere, not only in components. But let’s see how we can avoid it in components.

Immutable Inputs

Thankfully, Angular gives us two ways to create inputs, that can not be modified inside the component: accessors and signals.

In Angular before v17 accessors were the only way:

@Component()
export class ShoppingCart {
  private _items: Item[] = [];

  @Input() set items(items: Item[]) {
    this._items = items;
  }

  get items() {
    return this._items;
  }
}

In Angular v17.1 we got Signal Inputs:

@Component()
export class ShoppingCart {
  items = input<Item[]>([]);
}

Fewer lines, more awesomeness.

There are also more practical reasons to use signal inputs over setters, you can read about them in this article by Matthieu Riegler.

Now if we try to update items inside the component:

@Component()
export class ShoppingCart {
  items = input<Item[]>([]);

  private readonly api = inject(Api);

  constructor() {
    this.api.getCartItems().subscribe((items) => {
      this.items.set(items);
      //         ^^:
      // 🔴 Property 'set' does not exist on type 'InputSignal<Item[]>'.
    });
  }
}

TypeScript generates an error and protects our code.

If you encounter an error like this, do not try to find a workaround — Angular and TypeScript are on your side here and trying to help you. Modify your code to fix the bug. Sometimes it will require effort and time, but you’ll fix one of the nastiest kinds of bugs.

To fix our example, we should decide which part of our code should be the source of truth for the list of items in our shopping cart. Only that code will be allowed to modify (mutate) the list of items. Also, this code should be responsible for protecting the list from undesired modifications.

In our example, the root component doesn’t need to know what items are in the shopping cart, so it should either the Api service (which is shared globally), or the ShoppingCart component.

In real apps, we might need information about the shopping cart items not only in the ShoppingCart, but also in the navigation components.

So, let’s make the Api service the source of truth for this list:

https://medium.com/media/14c53950aed6006579b097ac1a4fa4a9/href

Now, if you explore the source code, you’ll find that most of the logic is moved to the Api service, and this service now has the only source of truth for the shopping cart items. And now, this service protects this source of truth from unintentional modifications.

  addItemToCart(item: Item) {
    if (untracked(this.$isLoading)) {
      return;
    }
    this._$cartItems.update((items) => Array.from(new Set([...items, item])));
  }

If you are curious why untracked() is used here, this article will be interesting for you.

The code of our components becomes much more compact, and the ShoppingCart component is now a “dumb” component.

export class ShoppingCart {
  items = input<Item[]>([]);
  removeItem = output<Item>();

  protected remove(item: Item) {
    this.removeItem.emit(item);
  }
}

The Api service has a little more code now, but for a very good reason — we’ve fixed a bug!

This article uses new features of Angular v17.1, but you could achieve it with just accessors and observables in any version of Angular. Code examples are far from perfect, and it was done intentionally to illustrate how a bug can be introduced and fixed.

The “Signal Source of Truth” architecture (or “rule,” or “principle”) states that if some information is shared across the application, there should be only one part of the code that can mutate this information. This principle can protect your application from bugs, which, as is often the case in practice, are much worse than theoretical examples in articles. Apply it to your components and services to make them more robust!

Powering Angular with Rust (Wasm)

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:45:54 GMT

“Red Sunset on the Dnipro”, Arkhip Kuindzhi, 1905

This article explains how to set up and start using Rust in your Angular application.

Why?

If the code of your app has parts where you need to work with a large amount of data (especially numbers), WebAssembly can do it much faster.

Examples include drawing, computing dynamic reports, complicated calculations (geodesy, astronomy, physics…), cryptography, LLM, image editing, video processing, games, and so on.

In this article, we’ll create an Angular workspace with an application and a library, written in Rust. Rust library we will compile into the WebAssembly (Wasm) module, and our Angular app will use this module.

Installation

Install Rust. Visit https://www.rust-lang.org/tools/install and you’ll find a command to install rustup. I know, an option that says “run some script fetched by curl” might look suspicious, but it is a safe and very convenient way. Currently, the command is:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Install wasm-pack:

cargo install wasm-pack

Angular Workspace

There are multiple ways to create an Angular workspace, and I would recommend Nx, but let’s not increase the complexity of this article and use the required tools only.

Don’t forget to update your Angular CLI:

npm i -g @angular/cli

In your terminal, navigate to the folder where your workspace should be created, and run:

ng new ng-wasm-example --no-create-application

Go to that new folder and generate an app:

cd ng-wasm-example
ng g application example-app

There are multiple ways how to use a Wasm module in our Angular app, and we’ll go with the easiest* one: inside our Angular workspace, we’ll create a regular Angular library, that will be a wrapper for our Rust library. This wrapper will also export types and a function to initialize our Wasm module.

ng g library wasm-example

*We could create a Rust library directly inside our app, and it would be even easier to compile .wasm file to some assets folder. But then other libraries of our application could not use this Wasm module, so it’s not a scalable and maintainable approach.

Rust Library

Let’s create a Rust library inside our Angular :

cd projects/wasm-example/src/lib
cargo new --lib example-rust-lib --vcs none

Option --vcs none will prevent the creation of a git repository — we are already inside an Angular workspace repository.

Now let’s edit Cargo.toml file of our library:

[package]
name = "example-rust-lib"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[profile.release]
lto = true
#opt-level = 's'

[dependencies]
wasm-bindgen = "0.2"

We’ve added [lib] section to specify crate-type, and added wasm-bindgen dependency.

In lib.rs replace content with this line:

use wasm_bindgen::prelude::*;

This line runs a bunch of tools to create a communication bridge between JavaScript and Rust.

Now you are ready to write your next masterpiece in Rust.

But that’s an exercise for you, dear reader. This article will go the classic way and calculate something useless, but computationally expensive:

use wasm_bindgen::prelude::*;

pub fn factorial(num: u128) -> u128 {
    match num {
        0 => 1,
        1 => 1,
        _ => factorial(num - 1) * num,
    }
}


#[wasm_bindgen]
pub fn get_factorial(num: u8) -> String {
    let mut f: u128 = 0;
    for _ in 0..10000000 {
      f = factorial(num as u128); 
    }
    f.to_string()
}

The get_factorial function has an instruction above that tells wasm_bindgen to make this function callable from JavaScript.

Now save your files and create a package:

cd example-rust-lib
wasm-pack build --target web

It will take some time when you run it for the first time.

The second command (wasm-pack build --target web) we have to run every time we modify our Rust library.

wasm-pack will generate pkg folder with a few files:

📂 pkg
├── 📄 .gitignore
├── 📄 example_rust_lib.d.ts
├── 📄 example_rust_lib.js
├── 📄 example_rust_lib_bg.wasm
├── 📄 example_rust_lib_bg.wasm.d.ts
└── 📄 package.json

File example_rust_lib_bg.wasm is our Wasm module!

Now in our wrapper library, let’s export information about get_factorial.

In file projects/wasm-example/src/public-api.ts (public API of our wrapper library), let’s replace content with:

import init from './lib/example-rust-lib/pkg';
export { get_factorial } from './lib/example-rust-lib/pkg';
export { init as initExampleRust} ;

Replace the name of the last export (initExampleRust) with something more suitable for your library, but don’t export it just as init, because you might have multiple libraries.

In the .gitignore file generated by wasm-pack (projects/wasm-example/src/lib/example-rust-lib/pkg/.gitignore), replace * with *.wasm, because other files are quite useful for us (they provide types).

That’s it, our library is ready to use!

Preparing our workspace

In tsconfig.json (that is located in our repository root), modify “paths”:

    "paths": {
      "wasm-example": [
        "./projects/wasm-example/src/public-api.ts"
      ]
    }

This way we can get code completion in IDE without re-building a library.

Our app will need the .wasm file that our library generates, let’s declare it in angular.json.
Add path to .wasm files, generated by example-rust-lib, into assets option:

{
  "projects": {
    "example-app": {
      "architect": {
        "build": {
          "options": {
            "assets": [
              {
                "glob": "**/*.wasm",
                "input": "projects/wasm-example/src/lib/example-rust-lib/pkg"
              }
...

Calling Rust function in Angular app

After all these preparations, we can finally start using our awesome Rust library, our masterpiece!

Replace the content of projects/example-app/src/app/app.component.html with this:

<input max="22" min="1" type="number" placeholder="Input a number" #inp/>

<button 
  type="button" 
  (click)="calculate(inp.value)" 
  [disabled]="calculating()"
>
  Calculate
</button>

@if (!calculating()) {
  @if (jsResult()) {
    <div>Result in JS: {{ jsResult() }}, calculated in {{ jsTime() }}</div>
  }
  @if (rsResult()) {
    <div>Result in Rust: {{ rsResult() }}, calculated in {{ rsTime() }}</div>
  }
}

For app.component.scss:

:host {
  display: flex;
  flex-flow: column;
  gap: 1em;

  input {
    width: 10em;
    padding: 0.75em;
  }

  button {
    padding: 0.5em;
    width: 11.75em;
  }
}

And in app.component.ts we are initializing (loading) our Wasm module and then using it:

import { ChangeDetectionStrategy, Component, type OnInit, signal } from '@angular/core';
import { get_factorial, initExampleRust } from 'wasm-example';

@Component({
  selector: 'app-root',
  standalone: true,
  imports: [],
  templateUrl: './app.component.html',
  styleUrl: './app.component.scss',
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class AppComponent implements OnInit {
  jsResult = signal<string>('');
  rsResult = signal<string>('');
  jsTime = signal<string>('');
  rsTime = signal<string>('');
  calculating = signal<boolean>(false);

  ngOnInit() {
    initExampleRust();
  }

  calculate(inp: number | string) {
    this.calculating.set(true);

    setTimeout(() => {
      const n = typeof inp === 'number' ? inp : parseInt(inp, 10);
      const jsTimeStart = performance.now();
      let f = 0;
      for (let i = 0; i < 10000000; i++) {
        f = factorial(n);
      }
      this.jsResult.set(f.toString());
      this.jsTime.set(((performance.now() - jsTimeStart) / 1000).toFixed(4) + 's');

      const rsTimeStart = performance.now();
      this.rsResult.set(get_factorial(n));
      this.rsTime.set(((performance.now() - rsTimeStart) / 1000).toFixed(4) + 's');

      this.calculating.set(false);
    }, 50);
  }
}


function factorial(x: number): number {
  if (x === 0) {
    return 1;
  } else {
    return x * factorial(x - 1);
  }
}

You can notice, that in our Rust code and our TypeScript code, we are calculating the same factorial 1 000 000 times, using the same algorithm without optimizations. That’s because otherwise, we would spend more time on the overhead of calling functions from a Wasm module.

In your terminal, run ng serve and in the opened app try to input “22”:

And now it works!

This article only explains how to start using Rust in your Angular apps. The real usage will require much more knowledge, and one article is not enough to explain all the details about wasm-bindgen, WebAssembly modules, their size optimizations, and other things.

But now you have a starting point — the first step is always the hardest.

References

Starting a Modern Angular Application

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:45:34 GMT

“Window Opening on Nice”, Raoul Dufy, 1928

The initial architecture of a web application is fundamentally important — it will affect your app for multiple years, impacting not only development but also the user experience. Things like lazy loading, bundle size, icon reuse, and other small details will influence the user experience, not just CI time, code reuse, or the onboarding process.

In this article, I’ll review the tools and options we have when creating a new Angular app and which of them, in my opinion, should be chosen.

Workspace

So the first thing we should create is a “workspace”. We should decide what structure our application will have — where all the components, services, and other things will be located.

Let’s discuss 3 ways of creating an initial structure:

Using Angular CLI, without separation by sub-modules/packages/libraries;
Using Angular CLI to create a monorepo, all the code is in libraries;
Using Nx to create a monorepo.

There are other tools to create a monorepo, but that would take another article to describe them all :)

So let’s compare what pros and cons every option has:

Angular CLI, without separation by sub-modules/packages/libraries

Pros:

Very easy to follow. Developers of any level can create a new component in the correct folder;
No additional dependencies.

Cons:

Very fragile because of tight coupling. Imports use relative paths: import { NavbarComponent } from '../../../shared-components/navbar/navbar.component', and if something is moved or renamed, many dependent components/services might need an update. A smart IDE can help with this, but not with a 100% guarantee. Moving and renaming things become dangerous;
Easy to create circular dependencies and ruin lazy-loading. See the example below;
Lack of modularity. Moving some code to a separate library requires enormous effort in checking dependencies, and often this task remains forever in the backlog, with functionality just being copy-pasted to another app or project;
test, lint, and build will always handle all the code you have. The more code you have, the longer these commands take, even if only one line in one component was changed;
Upgrades of tools like linters are not handled by ng update - configs will remain the same, even if a linter or test runner library has a major version upgrade and requires modifications in configs.

Example of how the lazy-loading can be broken with this structure:

Component A imports Component B
Component B imports Service S and Component C
Component D imports Component A and Component B
When any component imports just a single Component D, every part listed above is imported as well. This happens very often in real apps. Ruining a lazy-loading is especially easy with this structure.

Angular CLI to create a monorepo, all the code is in libraries

Pros:

Modular. Every library can be reused by multiple apps or even moved to its own repo and published to a registry. Then, it can be added to dependencies with 0 changes required in the code of other apps/libraries (because all imports are already non-relative);
No additional dependencies.

Cons:

Every time you create a library you’ll need to manually modify the paths in tsconfig.json, because Angular CLI will generate paths to dist folder, so to get updates from any library, you need to build it first. And because all of the code is libraries, that would be a nightmare in ng serve mode, so you’ll change the path in tsconfig to the public-api.ts file of a library you created
No module boundaries tracking. Developers should create a document that explains the connections across modules to avoid circular dependencies. This document should be kept up to date and strictly followed every time a developer creates a library. There are tools such as madge which help with this, but they still should be run manually.
test, lint, and build will always build every existing library and app. The more code you have, the longer these commands take, even if only one line in one library was changed.
test, lint, and build can only run consecutively, handling one library/app per run.
Upgrades of tools like linters are not handled by ng update - configs will remain the same, even if a linter or test runner library has a major version upgrade and requires modifications in configs.

Using Nx to create a monorepo.

Pros:

Modular. Every library can be reused by multiple apps or even moved to its own repo and published to a registry. Then, it can be added to dependencies with 0 changes required in the code of other apps/libraries (because all imports are already non-relative).
Easy to configure e2e-testing with Playwright (comes out of the box with Nx).
test, lint, and build will:
handle libraries in parallel (the more cores your machine has, the sooner all the steps will be completed);
only run for modified code — if just one library is modified, just that library will be linted and tested;
use local cache — if code is not changed, results will be reused, even if commands are executed for all libraries (this behavior can be modified with --skipNxCache).
Nx automatically controls module boundaries.
nx migrate updates configs of linters and test runners when their version is updated.

Cons:

Nx as an additional dependency.

You can read here how Nx recommends organizing your workspace.

There is also an excellent article, “Managing TypeScript Packages in Monorepos”.

What you choose from these options is up to you. My recommendations:

Do not pick option 1, even if your app is small and you’re intimidated by the amount of boilerplate that other options bring — you’ll generate it once and forget about it;
If you decide that the maintenance cost of the Nx dependency is too high compared to the benefits it provides, use option 2, and you can add Nx later. If you go this route, generate a multi-project workspace — switching from a single-project to a multi-project workspace might take more time than expected, but doing it from the start will cost you nothing;
I recommend option 3, as it significantly improves maintenance (not only of your code but also of your tools) and reduces generated boilerplate.

Style

First of all, use Tailwind CSS!

It is an excellent tool. If your team is more familiar with Bootstrap, it might be difficult to make the switch, but consider this argument: at the time of writing, Tailwind CSS has more than twice the weekly downloads on npm than Bootstrap.

You’ll also need UI components (date picker, tabs, and so on). Here we have a lot of libraries, you can easily find them. Some of them:

PrimeNG: has a lot of components, can be styled using CSS variables, and has a plugin for Tailwind CSS support;
Angular Material: has a lot of components and tools, can be styled using CSS variables (including the variables generated by Tailwind CSS), maintained by the Angular team, and they put a lot of effort into supporting accessibility features;
spartan/ui: based on TailwindCSS, not so many components, in alpha stage;
daysiUI: framework-agnostic, based on Tailwind CSS.

If you wonder why some libraries you know and love are not on this list, the answer is “for brevity” - enlisting them all would be pointless when we have so many search tools.

When picking a library, I recommend checking the following:

If it can be styled using CSS variables;
If it doesn’t require additional dependencies, that are maintained by someone else;
If Angular is the only JS part that it requires;
If it’s popular and actively maintained.

When the tool you picked asks you what format of CSS files you want, pick CSS — Tailwind works better with CSS, and in modern browsers, CSS can do things that were implemented only in SASS before, like nesting or variables.

SSR

When the workspace generator asks you if you want SSR, answer “yes” even if you are 100% sure your app will never use Server Side Rendering.

The code you write should be compatible with SSR anyway. Because when you want to reuse some of the libraries you created for this app, you might be surprised how much effort and how many breaking changes are required to make the existing code compatible with SSR. And if you turn on SSR mode for the serve command, you’ll quickly learn what things to avoid to make code SSR compatible, and it will cost you nothing to write such code from the beginning.

If your app doesn’t need SSR, you can just set "ssr": false in the configuration file for the build command and forget about it. But your code will still be reusable in any app.

Standalone

Modern Angular and Nx will generate standalone components, directives, pipes, and libraries by default, without NgModule. Do not try to change it — this is the direction the framework is moving towards, and creating NgModules at this point is pointless. There are still modules, of course, in the libraries and the framework itself, and you’ll use them, just don’t create new modules.

Reactivity

You are creating a new app, so it should use the latest features of Angular and be aligned with the trends in Angular evolution. Create a “zoneless” application. At the time of writing this article, it means that you’ll have to add provideExperimentalZonelessChangeDetection() to your list of providers in the application config.

Don’t be afraid of the “experimental” part — it works very well, even in the most complicated cases, and it might only require some workarounds if the libraries you use have usages of NgZone.onMicrotaskEmpty, NgZone.onUnstable, and NgZone.onStable. Because you are creating a new app, the chances of encountering such cases are low, as Angular is moving toward zoneless architecture, and libraries will support it. Right now, if a library supports the OnPush strategy and doesn’t use the methods of NgZone mentioned above, such a library is fully compatible with “zoneless” Angular apps.

If your app is zoneless, every component has a change detection strategy OnPush and you use only signals in your template — Angular will benefit you with the best possible performance. And in the future, such apps will get even more performance optimizations in the framework core.

State Management

I’ve built multiple apps using the approach explained in this article of mine: Application State Management with Angular Signals.

If you feel that your app is going to be quite complicated and you don’t think createEffect() and signals will be enough — I would recommend giving a try to SignalStore — some professionals I know and respect use this library and love it.

That’s it, you definitely will not need more complicated solutions.

And, of course, I recommend my libraries as helpers:

Collection for managing the state of lists/collections;
Reactive Storage for synchronizing data across tabs/windows using Signals, Observables, or Promises.

Testing

For e2e, I recommend Playwright, and if your team really loves to test things — Storybook (in addition).

For unit tests, I recommend Vitest. If you prefer something else — pick a tool that runs tests in a real browser (headless). That makes a huge difference.

Strict TypeScript + Linters

Here are options in tsconfig I use as basis and recommend for your project:

{
  "strict": true,
  // DO NOT remove 'emitDecoratorMetadata'! '@typescript-eslint/consistent-type-imports' rule requires it
  "emitDecoratorMetadata": true,
  "importHelpers": true,
  "noFallthroughCasesInSwitch": true,
  "noImplicitAny": true,
  "noImplicitThis": true,
  "noImplicitReturns": true,
  "noImplicitOverride": true,
  "noUnusedLocals": true,
  "noUnusedParameters": true,
  "strictNullChecks": true,
  "strictPropertyInitialization": true,
  "useUnknownInCatchVariables": true,
  "noPropertyAccessFromIndexSignature": true,
  "angularCompilerOptions": {
    "strictInjectionParameters": true,
    "strictInputAccessModifiers": true,
    "strictTemplates": true,
    "strictStandalone": true,
    "fullTemplateTypeCheck": true,
    "enableI18nLegacyMessageIdFormat": false,
    "disableTypeScriptVersionCheck": true,
    "extendedDiagnostics": {
      "checks": {
        "optionalChainNotNullable": "suppress",
        "nullishCoalescingNotNullable": "suppress",
        "suffixNotSupported": "warning",
        "textAttributeNotBinding": "warning",
        "invalidBananaInBox": "error",
        "missingControlFlowDirective": "error",
        "missingNgForOfLet": "error",
        "controlFlowPreventingContentProjection": "error",
        "unusedStandaloneImports": "warning"
      },
      "defaultCategory": "error"
    }
  }
}

That’s not the whole config, just options related to code check.

And ESLint rules:

{
    'no-extra-boolean-cast': 'error',
    'no-case-declarations': 'error',
    '@typescript-eslint/consistent-type-exports': 'error',
    '@typescript-eslint/consistent-type-imports': 'error',
    '@typescript-eslint/ban-ts-comment': ['off'],
    '@typescript-eslint/no-explicit-any': ['error'],
    '@typescript-eslint/no-non-null-assertion': ['error'],
    '@typescript-eslint/no-unused-vars': [
      'error',
      {
        argsIgnorePattern: '^_',
        varsIgnorePattern: '^_',
        caughtErrorsIgnorePattern: '^_',
      },
    ],
    'rxjs-angular-x/prefer-takeuntil': [
      'error',
      {
        checkComplete: false,
        checkDecorators: ['Component', 'Directive', 'Injectable'],
        alias: ['takeUntilDestroyed'],
        checkDestroy: false,
      },
    ],
    'rxjs/ban-observables': ['error'],
    'rxjs/ban-operators': ['error'],
    'rxjs/no-connectable': ['error'],
    'rxjs/no-cyclic-action': ['error'],
    'rxjs/no-compat': ['error'],
    'rxjs/no-ignored-replay-buffer': ['error'],
    'rxjs/no-unsafe-catch': ['error'],
    'rxjs/no-unsafe-first': ['error'],
    'rxjs/no-unsafe-switchmap': ['error'],
    'rxjs/no-async-subscribe': ['error'],
    'rxjs/no-create': ['error'], //
    'rxjs/no-ignored-observable': ['error'],
    'rxjs/no-exposed-subjects': ['error'],
    'rxjs/no-nested-subscribe': ['error'],
    'rxjs/no-ignored-notifier': ['error'],
    'rxjs/no-redundant-notify': ['error'],
    'rxjs/no-subject-unsubscribe': ['error'],
    'rxjs/no-unbound-methods': ['error'],
    'rxjs/no-unsafe-subject-next': ['error'],
    'rxjs/no-unsafe-takeuntil': ['error'],
    eqeqeq: ['error', 'smart'],
    'prefer-const': 'error',
    'no-unused-expressions': 'error',
    '@angular-eslint/use-lifecycle-interface': 'error',
    '@angular-eslint/no-input-rename': 'off',
    '@angular-eslint/no-empty-lifecycle-method': ['error'],
  }

Plugins for RxJS:

As always, linters’ rules are a very opinionated thing, but if you are looking for an initial setup — this will be helpful and will help you avoid a lot of errors.

Immutability

Make your data structures immutable by default. Don’t expect that your view will be updated because you mutated some field of a large structure — that contradicts how Angular change detection works, so it’s the wrong approach.

Reactivity in Angular works best with Signals, and Signals compare their values by reference (you can change it, but deep checks are expensive and not always safe). This means that you need to create a new value for a signal every time you want to see any changes in your view.

In this article of mine, you can read more about how to implement the simplest kind of immutability without any additional tools.

Nice Little Things

If you haven’t tried it yet, try mat-icon from Angular Material + icons registry. The SVG will be inlined, so you can affect currentColor and set CSS variables, which opens up a lot of possibilities. It is much better than icon fonts — you are not limited by a predefined set of images and can use literally any image you want, even with animations (for some very fancy cases). And they look sharper :)

Nice source of SVG icons: Lucide.

type-fest is a great tool that will add 0 bytes to your bundle.

Try tailwindcss-safe-area if you care about how your app looks in landscape mode on mobile devices.

Things to Avoid

Some Angular features might stay here for a while, but will not be actively developed. I recommend avoiding the following:

Angular Animations — use CSS animations instead. Yes, “leave” animations can’t be replaced, but that’s the only thing;
Old control flow directives: ngIf, ngSwitch*, and, especially ngFor;
If you use Angular Material, only style it using CSS variables, do not create CSS rules with their class names in selectors. It might cause very painful breaking changes.

That’s what I use to create super-performant modern Angular apps. I hope this information will be useful for your awesome apps as well!

Examples of linkedSignal() usage in Angular applications

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:45:10 GMT

“Cicada”, Omoda Seiju, 1930

Angular 20 has been released, linkedSignal() is now stable, and I want to share my experience using this powerful function.

The main use case

linkedSignal() is a perfect tool when you want to compute some initial value, then let the user modify it, and still keep it in a reactive signal.

export class CategoriesComponent {
  categories = input.required<Category[]>();

  selectedCategory = linkedSignal(() => this.categories()[0]);

  pickCategory(cat: Category) {
    this.selectedCategory.set(cat);
  }
}

How it works: the initial value of the selectedCategory signal will be computed as this.categories()[0] .

this.categories is a signal, and every time this signal changes, selectedCategory will be re-computed.

Technically, it is a bit more complicated: linkedSignal() will not re-compute its value at the moment when any of the signals it consumes notifies about a possible change, but rather when a consumer of the linkedSignal() reads it and the linkedSignal() has unchecked notifications about changes. However, stating this every time would make it much more difficult to read.

Those who are familiar with computed() might say that linkedSignal() works the same, but there are two important differences between them.

Look at the pickCategory() method: Here we set the new value for the selectedCategory signal, and this value will remain until the categories signal “emits” a new value — then selectedCategory will be recomputed again, and the value we previously set in that method will be overridden.

It is very useful for:

displaying pre-computed forms (using previously saved data or default values) and letting the user change the values (to save them later, or just to affect other parts of the app);
pages where the initial properties should be loaded from the API or default values, not the URL, and the URL cannot be the source of truth (large tables with filters and pagination, games, 3D scenes), and the user is supposed to modify the values;
components where one input control might restrict the range of allowed values of other input controls. For example, a date picker where the user picks the year, month, and date separately;
computed (derived) signals that should know the previously computed value.

And that is the second important difference: linkedSignal() not only returns a WritableSignal, but also lets us use the previous value.

Example:

export class VehiclesComponent {
  showAtv = linkedSignal<boolean, boolean>({
    source: () => this.store.hasATVInfo(),
    computation: (source, previous) => {
      if (source === false) {
        /**
         * If other fields of the form were changed and
         * we no longer have ATV vehicle info,
         * but we are displaying it as "yes,"
         * leave it as "yes" - do not reset this switch.
         * Otherwise, the opened form will be unexpectedly
         * (for the user) closed, and the user might still
         * want to edit this form, bringing in the new ATV info.
         */
        if (previous?.value === true) {
          return true;
        }
      }
      return source;
    }
  });
}

Sometimes you don’t need a WritableSignal, and you would like to use computed(), but you absolutely need the previous value to compute the new one, even if computed() is supposed to be pure. It’s not an idiomatic example, but for these exceptional cases, you can use this trick:

export class Example {
  someInput = input<string>();

  myComputedSignal = linkedSignal<string, string>({
    source: this.someInput,
    computation: (source, previous) => {
      if (previous?.value === 'SOME VALUE') {
        return 'SOMETHING ELSE';
      }
      return source;
    }
  }).asReadOnly(); // <- and it's not writable anymore
}

With great power…

When we have more than one source of truth, things become less declarative and less safe. We should use linkedSignal() with care.

Look at this example:

https://medium.com/media/4fd5637d9a92f2085179c0a453aebf34/href

If a user doesn’t want to be named “Goblin,” they will enter something else, for example, “Wizard.” Now they see in the form that their favorite color is Green and their nickname is “Wizard.” But their favorite color is purple, they input “Purple,” and now they are named “Purple Goblin.” Not an expected behavior, to say the least!

In this form, after “nickname” was edited, it should not be derived (computed) anymore.

linkedSignal() is a wonderful tool that can be extremely useful sometimes. Happy coding!

Improving Code Reusability in Angular Projects

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:43:55 GMT

“The Pond at Benten Shrine in Shiba”, Hasui Kawase, 1929

In this article, you’ll find recommendations on how to make your Angular components and services more reusable, maintainable, and scalable.

Pure Functions

The most effective way to make your code reusable is to move as much code as possible to pure functions.

Such functions have no side effects, have no state, and don’t mutate their arguments. Every time we call a pure function with the same arguments, it will return the same result.

Let’s refactor a component’s method into a pure function:

export class ExampleComponent {
  @Input() items: Item[];
  @Input() users: User[];

  @Output() connected = new EventEmitter<Item>();

  private readonly errEmptyItemMsg = 'Item data can not be empty';

  //...

  protected addConnection(toItem: Item) {
    if (!toItem.data) {
      this.displayError(this.errEmptyItemMsg);
      return;
    }

    let hasNewConnection = false;

    for (const user of this.users) {
      if (!user.itemRefs.includes(toItem.id)) {
        user.itemRefs.push(toItem.id);
        hasNewConnection = true;
      }
    }

    if (hasNewConnection) {
      this.connected.emit(toItem);
    }
  }

  private displayError(errMsg: string) {
    // ...
  }
}

Method addConnection() validates toItem, then adds a new item ID to every user. It can display an error and emit an event.

Let’s imagine that this method has not 18 lines, but 180, with complex validation rules. And suddenly, we need exactly this logic, with exactly the same validation (or a new data construction) in a completely different module of our application. Do not look at the “Copy” and “Paste” menu items in your editor — if validation logic is changed in one place, it should be modified in every other place.

Even if we were to swear to update this code in every place on every change, it’s still tightly coupled to our component. So, we simply cannot copy this code to any other place without also copying dependent parts of the component. You can easily spot this by looking for the usages of this.:

this.displayError()
this.errEmptyItemMsg
this.users
this.connected

We can split addConnection() into two methods: validation and linking.

export class ExampleComponent {
  //...
  @Output() usersChange = new EventEmitter<User[]>();
  
  protected addConnection(toItem: Item) {
    if (!isItemConnectable(toItem)) {
      this.displayError(this.errEmptyItemMsg);
      return;
    }

    const { users, hasNewConnection } = addItemToUsers(toItem, this.users);

    if (hasNewConnection) {
      this.connected.emit(toItem);
      this.usersChange.emit(users);
    }
  }
  
  // ...
}

export function isItemConnectable(item: Item): boolean {
  // here we have 100 lines of validation...
  // ...
  // ... very complex logic here ...
  // ...
  // ... not like this :)
  return !!item.data;
}

export function addItemToUsers(item: Item, users: User[]): {
  hasNewConnection: boolean,
  users: User[],
} {
  let hasNewConnection = false;
  const updatedUsers = [] as User[];
  for (const user of users) {
    if (!user.itemRefs.includes(item.id)) {
      updatedUsers.push({ ...user, itemRefs: [...user.itemRefs, item.id] });
      hasNewConnection = true;
    } else {
      updatedUsers.push(user);
    }
  }
  return {
    users: updatedUsers,
    hasNewConnection
  };
}

Because the new functions should be pure, they cannot modify their arguments. So, in addItemToUsers(), we had to create a new array of users and make a shallow copy for the users we want to connect, instead of mutating them directly.

// before
if (!user.itemRefs.includes(toItem.id)) {
  user.itemRefs.push(toItem.id);
}

// after
if (!user.itemRefs.includes(item.id)) {
  updatedUsers.push({ ...user, itemRefs: [...user.itemRefs, item.id] });
} else {
  updatedUsers.push(user);
}

this.usersChange.emit(users);

This way, we actually fixed quite a nasty bug of data de-synchronization, described in more detail in this article. Now we will emit a new array of users every time a new connection is created, so the parent component will have the correct data. Bingo!

Now we can reuse our super complex logic in other places — the new functions have no dependencies, all they need are their arguments.

When refactoring your code into pure functions, require as little information in arguments as possible. If your function requires product: HugeProductDataStructure and in its code it uses product just for product.id and product.price, then it is much better to define arguments like productId and productPrice, rather than requiring a structure that might be difficult to fetch in some places of your code. But don’t over-explode your list of arguments ;)

Component State Management

Some methods just can not avoid using this because they have to modify the state of your component. You can still make such code reusable, by moving this logic into a separate file, called “local store”.

A local store might be represented as a class or as a function (see examples in NgRx SignalStore docs).

Here is an example of how we could move logic, responsible for saving users, to a local store:

@Injectable()
export class ExampleStore {
  private readonly api = inject(ApiService);

  readonly saveUsers = sideEffect<User[]>(_ => _.pipe(
    exhaustMap((users) => this.api.saveUsers(users)),
    catchError((err) => {
      this.displayError(err.msg);
      return EMPTY;
    })
  ));
}

@Component({
  selector: 'app-example',
  // ...
  providers: [ExampleStore]
})
export class ExampleComponent {
  // ...
  private readonly store = inject(ExampleStore);

  protected saveUsers() {
    this.store.saveUsers(this.users);
  }
}

Because of this refactoring, we now can reuse logic, responsible for saving users' data (which often is not as primitive as this example) in other places of our code, simply by injecting the ExampleStore.

You can read more about the benefits that this refactoring brings, and about different kinds of stores, in this article.

In the previous code example, you might notice that saveUsers() has just one line, and some of you may ask, “Maybe we could just call this method directly from the template? Why the extra wrapping?”

The answer here is: it is up to you to decide. Some developers trust their local stores and IDEs, so if the store’s method name or signature changes, the IDE will automatically update it in the template. Other developers say that templates calling only component’s methods look cleaner and more reliable to them. This topic is very subjective, and there cannot be only one correct answer.

Miscellaneous

Prefer composition to inheritance. Never extend components (yes, never). In some very rare cases, when you see that only inheritance can be used, it is okay to extend stores. However, never extend components. We might think that we increase code reusability this way, but there are other ways to achieve the same result without inheritance. What we sacrifice when we extend components is maintainability, and that is a very important aspect of the code.
Even if ::ng-deep is un-deprecated, try to avoid it. When it’s not possible (and there are such cases), use it with extreme care. To help your future self, use very specific selectors inside ::ng-deep. When you reuse components that use ::ng-deep, and these components have multiple levels of sub-components, things might quickly go out of control if the selectors inside ::ng-deep are not specific enough.
When using Observables, avoid nested subscriptions. Additionally, methods of your services that return observables are much more reusable than methods that subscribe. You don’t always need that level of reusability, but sometimes you might want to reuse code that is inside a method that subscribes and unsubscribes. In such cases, just refactor that method into two: one that returns an observable, and the second one that uses that observable.

Angular Signals: Best Practices

Stories by 🪄 OZ 🎩 on Medium — Wed, 10 Dec 2025 14:43:33 GMT

“Sun in the Afternoon”, Eugenie Bandell, 1913

In this article, I share my experience of working with Angular Signals after almost a year of using them.

When to use Signals?

In templates;
For state management;
When you need to react to changes in a value without a time aspect.

In Angular templates, Signals are better than Observables: they schedule Change Detection without any pipes, they are glitch-free, and you can read the same signal multiple times and it will be “free” in terms of performance (and read values are guaranteed to be the same). There are other reasons that are not so easy to explain briefly, but that’s already enough to make a rule: every variable (that might change) in your new templates should be a Signal.

Outside of templates, Signals also can be used for reactivity, but, as I mentioned, without a time aspect.

I once wrote a post on Twitter about it, and now I’ll post it here, updated and improved:

There are two ways to create reactive variables in Angular: Observables and Signals. If you describe in words, how your variable should express its reactivity, you’ll see what you need to use.

If the role of a variable can be described as conditions, then you need a Signal:

“if this variable has this value, then display this list”
“if this variable has this value, this button is disabled”

If the description of a variable’s role includes words, related to time, you need an Observable:

“when the cursor moves…”
“wait for the file uploading event and then…”
“every time this event happens, do this…”
“until this event…”
“for N seconds ignore…”
“after this request…”

Signals have no time axis, and they can not delay a value — they always have a value, and their consumers should be always able to read it.

Consumers of Signals, computed(), effect(), and templates do not guarantee that they will read every new value written to the Signals they watch. An updated Signal will be eventually read, not instantly after the update as it happens with Observables. Consumers decide when they will read the new value using their scheduling mechanisms. It might be “in the next task,” “during the next Change Detection cycle,” or at some other moment, up to the consumer.

When to use computed()?

Whenever you like!

computed() is the best thing in Angular Signals, incredibly handy and safe to use. Using computed(), you’ll make your code more declarative (you can read more about it in this article).

There are just two rules about the usage of computed():

Do not modify things in computed(). It should compute a new result, that’s it. Do not modify the DOM, do not mutate variables using this, and do not call functions that might do that. Do not push values to Observables — it will cause unintentional reactive context propagation (explained below for effect()). computed() should not have side effects, it should be a pure function.
Do not make asynchronous calls in computed(). This function does not allow modification of Signals (and it is amazingly helpful), but it can not track asynchronous code. Moreover, Angular Signals are strictly synchronous, so if you want to use asynchronous code in computed(), you are doing something wrong. So, no setTimeout(), no Promises, no other asynchronous things.

When to use effect()?

Angular docs say that you’ll rarely need effect() and discourage you from using it (copy, if docs will be edited).

And that info is correct: you rarely need effect()… if your code is declarative ;)

The more imperative your code, the more often you’ll need effect(). There is no code without imperative parts, but we all should try to make our code as declarative as possible, so we do need to use effect() as rarely as possible.

Besides the dangers, mentioned by Angular docs (infinite loops, change detection errors), there is another thing, that might be quite nasty: effects are executed in a reactive context, and any code you call in effect, will be executed in a reactive context. If that code reads some signals, they will be added as dependencies to your effect. Here Alex Rickabaugh explains the details.

I still don’t want to encourage you to use effect(), but I’ll give you advice on how to use it as safely as possible:

The function you provide to effect() should be as small as possible. This way it will be easier to read and spot erroneous behavior.
Read signals first, then wrap the rest of the effect into untracked():

effect(() => {
  // reading the signals we need
  const a = this.a();
  const b = this.b();
  
  untracked(() => {
    // rest of the code is here - this code should not
    // modify the signals we read above!
    if (a > b) {
      document.title = 'Ok';
    }
  });
});

More information about cases where untracked() helps can be found in this article.

Mixing Signals and Observables

…is ok!

Your code will have Signals and Observables, at least because Signals can not be used for every kind of reactivity (see detailed explanation above). It is not an issue, it is perfectly fine.

If you need some value from an Observable in your computed(), create a Signal using toSignal() (outside of computed()).

If you need to read a Signal in Observable’s pipe(), there are two ways:

If you need to react to changes in that Signal in your Observable, then you need to convert that Signal into Observable and add it using some join operator.
If you are sure you just need the current value of a Signal and you don’t need to react to its changes — you can read a Signal directly in your operators or subscribe(). Observable is not a reactive context, so you don’t need untracked() here.

The Most Popular Every Intention Articles in 2025

Ashley Janssen Consulting — Wed, 10 Dec 2025 13:00:30 GMT

2025 was a year of revisiting boundaries, learning to ask for help, and rethinking motivation. Here are the most popular articles from 2025!

Running PostgREST in Google Cloud-Run

Lucas DiCioccio's Blog — Wed, 10 Dec 2025 03:00:00 GMT

Running PostgREST over CloudRun: it works well and it's affordable.

ddoc

dystroy|Canop / blog — Wed, 10 Dec 2025 02:00:00 GMT

I moved the documentation of my free programs from MkDocs to ddoc.

Here's why.

I Wish People Were More Public

Fernando Borretti — Wed, 10 Dec 2025 02:00:00 GMT

On sharing more of yourself.

Getting into public speaking

James Brooks — Wed, 10 Dec 2025 02:00:00 GMT

Here are ten things I learnt about public speaking.

2025-12-09-002

Srijan Choudhary, all posts — Wed, 10 Dec 2025 00:50:00 GMT

tramp-hlo looks interesting. Anything that can make tramp on #Emacs snappier is a good thing in my books.

FreeBSD 15.0 post-upgrade reboot loop

The NeoSmart Files — Tue, 09 Dec 2025 21:34:30 GMT

This post is less of a deep dive into a bug I ran into upgrading an x86_64 machine from FreeBSD 14.3 to FreeBSD 15 and more of a PSA: I have a possible workaround for anyone that runs into the … Continue reading →

The post FreeBSD 15.0 post-upgrade reboot loop first appeared on The NeoSmart Files.

How 'What Can Go Wrong?' Went Wrong

Chandrapal Badshah | Security Engineer on Chandrapal Badshah — Tue, 09 Dec 2025 20:30:00 GMT

I recently spoke with a close friend who’s been in the security industry for over a decade. We discovered an interesting issue we both had, but never discussed. Both of us had become pessimistic. It’s not terminal pessimism. It’s not like there’s no point in living, doing anything, or initiatives. But it is subtle and strong enough to hinder growth. Let me tell you how I got here. After college, I got my first job as a Product Security Engineer.

Traits of a good Tech Lead

João Alves — Tue, 09 Dec 2025 17:07:40 GMT

The software development industry during the 2010–2020 decade created roles such as Engineering Manager (EM) and Tech Lead (TL). People had already been using one or the other, but during that decade, most companies adopted them. While they vary by company, they share common elements.

Note: this article is a translation from the original “Señales de un buen Tech Lead”, in Spanish. However, this post is slightly different and contains a short “Frequently Asked Questions” section.

What is a Tech Lead? How is it different from an EM?

Many people already have a clear idea, but here is my view of these two roles:

Engineering Manager: responsible for the team. Most of the work falls into three management areas:

People: ensuring people perform well and everything that comes with it (performance reviews, career development, etc.).
Product/project: ensuring sustainable delivery of required features (stakeholder management, expectations, scope negotiation, de-risking, etc).
Processes: how do you prioritize bugs vs new features? How do you decide what to work on this week? How do you run continuous improvement? The point is not to add processes ad nauseam. It is to find the balance needed for the team to operate independently — ideally without the EM — and to add some structure to natural chaos.

Tech Lead: responsible for the technical direction of the team. The focus is on three areas:

Architecture: define key technical decisions, review proposals, ensure solutions scale, and ensure that technical debt is manageable. Most of all, ensure debt is intentional, not accidental.
Quality: maintain high standards across code, reviews, testing, and observability. It is not about doing everything. It is about raising the bar for the team.
Mentorship: help engineers grow, unblock complex problems, share context, and enable better technical decisions across the team.

As you can see, these roles are very different and require distinct approaches. One person may hold both roles. In a way, the end of the zero-interest-rate era (ZIRP) and the focus on efficiency pushed EMs back toward a more hands-on approach.

Note: I excluded the Product Manager role from the diagram, since that is not the focus of today’s article. Your real world is probably more complex.

Operating models

There are several ways to have someone provide technical leadership within a team:

EM and TL are official roles held by two different people.
EM and TL are official roles held by the same person.
EM is the only official role, and engineers are expected to lead technical initiatives without holding that title. This implicitly means the EM ensures the team is covered across all three TL areas.

There are other setups, but these are the most common. We will explore a model with an EM and a TL reporting to them. Across the models, differences are not significant, though the details vary. In the EM+TL case, the director must define what “good” looks like. If there is no formal TL, the EM must understand which areas require coverage and evaluate engineers across their key dimensions.

Today, we will not talk about Staff or Principal Engineers who operate across multiple teams. That will be
for another article.

---

👋 Hi, João here. This is the opening post of a series designed for Tech Leads and Engineering Managers who want to lead with greater clarity and intention.

I’m currently writing “The Tech Lead Handbook”, scheduled for release in H1 2026. The ideas in this series will form its core.

If you want to join the waitlist, you’ll get a 25% launch discount.

---

How do I know if a TL is doing a good job?

Across the three pillars above, one constant is that the TL is expected to have a multiplier effect on the team. Effectively, it means the TL should not become a bottleneck. The TL should help the team become autonomous. If the team still relies on the TL for decisions after a reasonable adaptation period, it indicates that the way of working needs adjustment and that the TL is likely not fulfilling the role.

Still, this can sound abstract. In practice, a good TL looks a lot like a Staff+ engineer. Someone who goes beyond task execution and focuses on ambiguous or structural problems. Someone who works with clarity, good judgment, and range. Someone who provides technical direction, reduces ambiguity, and pushes the team toward decisions that serve the whole system, not just one area.

A TL defines the what and the how when needed. But also creates the conditions for others to do the same. They identify risks, simplify open problems, prevent scope creep, and align technical work with product goals. And, above all, a TL generates speed: with clear operating principles, with written artifacts that create space for reflection (Requests for Comments, proofs of concept, design proposals), and with decisions that others can understand and carry on without depending on the TL.

We can anchor this in concrete signals across the three pillars: architecture, technical scope, and operating principles.

Architecture

Helpful behaviors

Use Requests for Comments (RFCs) or other short documents to structure technical debates and force clarity: problem, alternatives, trade-offs, and decision.
Notice when a discussion goes on without progress and propose a proof of concept (PoC) or a small experiment to validate assumptions.
Make it explicit when decisions create technical debt and explain why it is acceptable at that moment.
Involve the team in key decisions so everyone understands the reasoning and can make sound judgments.

Behaviors that slow things down

Making improvised decisions in chats or hallways with no written record.
Extending meetings endlessly with no clear synthesis or next step.
Designing solutions without validating risks or assumptions with a prototype.
Being the only person who knows “how everything works” and becoming the keeper of knowledge.

Technical scope

Helpful behaviors

Actively negotiate with the EM and Product Manager on the balance between technical debt and value delivery. Understand business constraints and defend that quality is the only way to maintain mid-term speed.
Detect technical scope creep: extra complexity, bonus non-functional requirements, or decisions that enlarge the system without real value.
Simplify solutions by proposing reasonable technical phases: first, something that works, then something that scales. In other words, identify the minimum viable change.
Regularly review whether the current design still matches the problem. Remove parts that no longer help.
Surface dependencies or technical risks can delay the team if not addressed early.

Behaviors that slow things down

Adding technical requirements “just in case” and increasing delivery cost for no reason.
Overdesigning systems that could be simpler.
Ignoring signs that the team is taking on something too big for the available time.

Operating principles and team velocity

Helpful behaviors

Define written operating principles that serve as a compass: what we prioritize, what we avoid, and what “good” means for the team.
Influence without authority: persuade through reasoning and vision, not hierarchy. Seek consensus when possible, and use “disagree and commit” when needed to unblock the team.
Use these principles to accelerate decision-making and reduce dependence on the TL.
Review principles with the team regularly and adapt them to the product reality.
Promote consistent decisions so the team gains confidence and moves fast without asking for permission.

Behaviors that slow things down

Making ad hoc decisions that change every week and confuse the team.
Avoiding hard conversations due to fear of conflict (artificial harmony) or letting trivial debates (bikeshedding) stall the team.
Keeping personal criteria hidden and allowing each person to optimize based on their own preferences, with no shared technical direction.

Frequently Asked Questions

How do you think the role changes if the EM and TL are the same person?

When the EM is also the TL, the model can work, but it changes a few things.

Evaluation gets harder. The Senior EM or Director has less visibility into day-to-day technical work and therefore needs more context. That means more managing up from the EM/TL, and regular skip-levels so leadership can gain a clear sense of how the team operates.
Delegation becomes essential. One person cannot manage people, projects, and technical direction without becoming a bottleneck. The solution is to develop “champions” within the team for areas such as quality, security, and architecture, and to spread technical ownership.

If it works well, you should see three signals: the team maintains its pace, decisions don’t centralize in one person, and leadership has clarity about what’s happening. If those signs are missing, the model needs more structure around them.

---

I like the "keep personal criteria hidden" part, but there is always debate between imposing and convincing. Many times, even if we believe something is the right choice, people won’t like it for various reasons, and then you enter the territory of imposing things.

When something feels like “imposing”, it’s usually because the principles are not explicit, or because they weren’t co-created. That’s why I’d approach it from two angles:

Make the principles explicit. If the team agrees to “we prioritize X over Y” or to use specific standards, enforcing those standards isn’t burdensome. It’s consistency. Principles reduce subjective debates and prevent each person from optimizing in their own direction.
Reframe debates around outcomes, not preferences. Questions like “Are we solving the real problem?” and “Is this the smallest step that moves us forward?” help shift the conversation away from taste and toward impact.

When there’s disagreement on approach, run a small PoC with clear criteria. A one-day experiment is cheaper than a week of arguing, and data removes most of the emotion.

And yes, not every decision will please everyone. But in the long run, principled leadership with clear boundaries creates more autonomy, not less. Teams mature faster when decisions are coherent and aligned, rather than driven by who argues the loudest.

The real impact of a TL

At its core, the challenge of a Tech Lead is not about knowing more than everyone else. It is about creating an environment where the team can think better, decide better, and move better. Every organization and every team needs something different, so there is no universal recipe.

However, we can observe how work flows, how decisions are distributed, and how the team’s autonomy evolves. That is where you see the real impact of a TL. And maybe the question each TL should ask is not “Am I doing this well?” but “Is the team depending less on me each month?” That answer is usually more honest and valuable than any checklist.

---

🎁 Want to put this into practice with your team tomorrow? A gift for subscribers!

Friction between EMs and TLs often comes from unspoken expectations. To close that gap, I created a FREE alignment toolkit with three practical tools:

For Tech Leads: a self-assessment “semaphore” to fight impostor syndrome and know exactly where you add value (and where you are burning out).
For Engineering Managers: an evaluation “semaphore” to give objective feedback based on behaviors, not gut feelings.
For the team: an operating principles template to stop debating the same decisions every week.

Subscribe, complete this form, and I’ll send you the kit so you can move from intention to action. It is FREE!

— João

Demonstration Junction Repair on Downing in Denver

Josh Thompson — Tue, 09 Dec 2025 15:00:00 GMT

author’s note: This is a story about an demonstration I filmed. I demonstrated a proof-of-concept for ‘intersection repair’.

Lots/most intersections are broken in many ways. They don’t work very well, at least some of the time, for some of the users. Like anything broken, it can be repaired. I’ve got an interesting-to-me approach to repairing a broken intersection.

Traffic cones are the main tool, and I use those cones to shape and define the spaces for the cars.

on a recent warm saturday night I stumbled across of traffic cones, spread rather widely in a local neighborhood.

Earlier in the week Silva Construction had been doing concrete work all around the area. ~~I'm not sure what they were doing, but they were scattered all about the neighborhood.~~ turns out they’re repairing broken sidewalk! I’ve wanted this to happen for so long, Silva Concrete is great! Not only did they informally sponsor this proof of concept, monday morning they showed up and used the cones to block of the concrete they were repairing. 🎉

TODO: add link to photo album of the before/after treatment of Corona

I’ve done a lot with cones before, of course. Its come to be a refined process.

There were many, many more traffic cones in the vicinity than I used. I set the cones up on the way to a local climbing gym, did a board session, checked in on them on the way home. Every cone was exactly where I placed it.

Shout out Silva Concrete, for sure, for the cones.

So, the next morning, sunday morning, I was at cheesman, and from the park, one can see down maybe six blocks of 10th ave, and I could see that even the next day, the cones remained.

TODO link to photos down 10th from cheesman

so I did the park thing, then walked from the park to corona, where I’d placed the cones the night before. I passed more cones, and dotted those into the road in spots that caused delination and a bit of attention to be attracted.

Timelapse of me placing the cones & observations

The treatment (moving the existing traffic cones from the adjacent curb to this particular pattern on the Downing & 10th junction) brought about many, many changes.

Here’s a silent video. Literally. No audio, no commentary, and almost no editing. Thus, not necessarily a lot of story-telling.

I just wanted to get a first pass up, as I make it more self-explaining I’ll update this section. Below the video I list some of the changes. The video is a 4 minute long, 4x timelapse of the junction.

Here’s a graphic of the shape I had in my mind, as I placed the cones. I didn’t have as many as I’d like to have, else the finished shape would more closely match the green shape:

Changes From Placing These Cones

Some phenomina is hard to even write about. It’s best seen with the video slider going back and forth, showing something about the path a car took on a turn or whatever.

Alas, plenty of the changes are visible in the timelapse (like the effect the cones have on the path a vehicle takes), I’ll list that and more.

here’s a list:

before: 30 foot crossings for pedestrians on all sides, having to look left and right in some cases, sorta at the same time after: max crossing is 15 feet, with possible car traffic arriving from one side only

before: regular vehicle speeds of 40 mph after: most vehicle speeds much closer to 20 mph (no speed bump or stop sign or path deviation required)

more things:

reduced width means:

reduced time spent in the crossing for pedestrians AND other vehicles.
Much less space one has to be concerned about being inside of. Sharper delineations between the spaces

Reduced junction size

A huge component of this roads and junctions thing is that to dramatically increase the junction efficiency, one has to be able to reduce the size. Huge and inefficient becomes small and efficient.

The way to get some space back is to sorta ‘scribe’ the outer edge, define it with cones. Compare these two shapes:

They may look almost the same in size, but the inner shape is like 40% smaller than the outer one.

Here’s how I see in my mind the unimproved junction shape, and then the improved junction shape:

before-size: 300 square meters. After-size: 180 sq meters¹
the sounds improved. It used to be that many vehicles were accelerating through the junction. It’s one block from a traffic light and super market exit and it looks super open and wide. With the cones, almost every vehicle coasted or at worst very gently accelerated through it.

shared space vibes

In theory, someone should not be eligible to be destroyed by a car, simply for being in the wrong spot at the wrong time. Nor should they have to wait and defer a crossing to a person that is still hundreds of yards away, which is what happens when pedestrians are waiting to cross unbroken streams of vehicular traffic.

At the 2:51 point, a person in a car stops it to let some people on foot cross. This is a big deal. No signs demanded that the right of way be given to pedestrians in the crosswalk. There wasn’t a stop sign or a speed bump. It was a chill handoff of that space.

A little more squeezing of the lanes with the cones, and more and more of the passing vehicle traffic would stop as soon as pedestrians showed up to cross.

my ideal junction treatment turns it into a ‘shared space’ (vs a car-dominated space) where the larger/motorized vehicles defer to smaller/non-motorized/leg-powered vehicles. (counting walking people as vehicles here)

the experience for turning left and right off of downing is much improved

Notice the changed shape of left and right turns

I could imagine overlaying a line representing all the possible different left and right turns - sometimes cars turn fast, taking a wide turn. Sometimes too wide, too fast. Once the cones go out, some of the least desireable possible turning paths are eliminated, and more vehicles take a slower, defined turn.

That sort of turn makes it much safer for pedestrians crossing the road at the same time.

The turning into and out of the darkness of the shadow also complicates the junction. Reducing speed and complexity (as I did) makes everything move in a much flowier way.

Rear ending/tailgating/racing past behavior is eliminated

since both sides of the junction are constrained, if a vehicle stops to make a left or right turn and is waiting for the path to be clear, the vehicle behind them cannot fit around and race past.

There’s a tremendous rear-ending danger in the original intersection design.²

If a car were turning right, for instance, and suddenly stopped, noticing a pedestrian in the space in front of it, and got rear ended, it could end up bouncing into the space the person was occupying anyway.

The sounds. so much better.

cars are loud. so freaking loud. especially when accelerating up a hill, which is what every single car going north on downing is doing. this cone treatment encouraged gentler driving. While I was standing near it, I noticed that while some vehicles still drove very fast straight through the junction, the vast majority would at least remove their foot completely from the gas and would coast through the junction.

The acoustics were very improved. And the sound of racing/tailgating/rushing is unmistakable, even from a great distance.

manifesting `Repair as a Service`

In this capitalistic hellscape we live in, I could imagine Repair as a Service, sorta like Software as a Service. (in some circles, SaaS is the stuff).

TODO: add a section about why this satisfies capitalism, and not just via general harm reduction, risk mitigation, though there are billions of dollars of industry doing just that. Maybe this improves customer access. It’s known that foot traffic makes money, this is all in line with pedestrianizing/making pedestrian friendly spaces.

I have this thing about parking that’s conceptually related. A bit more capitalistic.

if something were a service, that means it can be purchased, and this is america, so if something is available for purchase, that means it’s available at all. Currently, however, one cannot, to my knowledge, quite purchase a repaired junction, the same way one can purchase a repair to some commonly repaired physical items, like vehicles, houses, devices.

In the spirit of write it now and the iterative nature of the internet, here’s two different options plausible ‘junction repair as a service’ solutions, and everything technically works so I can get this page live.

the ‘let josh truthfully say at any point in the future “someone has hired me/is hiring me at this very moment to run a pop-up experiment right here”:’ option:

👉 purchase ‘Josh’s Junction Coning’ via Stripe. google pay/apple pay works

A three-cheers-for-capitalism option. Includes above plausibility beard, and some recorded outputs and magical calculations:

👉 purchase ‘Josh’s Junction Repair Writeup’ via Stripe.

I’m pleased to talk about any of this. Email or Whatsapp or a walk is preferred, ranked by preference, reverse sorted.

Additional Reading

Footnotes

I popped this open on google earth. 300sq meters to 180 sq meters is a 40% reduction in size. WE REDUCED THE SIZE OF A CRITICAL PIECE OF INFRASTRUCTURE BY ALMOST HALF. It’s interesting to me. the junction was never ‘maxed out’ in terms of vehicles moving through it for a time frame, so a direct count of vehicles per minute doesn’t quite make sense, but the principal of it’s efficiency being unaffected even as the space required is reduced by over a third is, I think, clear enough. Here’s much more about this vehicles per square meter per minute value ↩
and of course ‘danger still persists’ with this treatment. ‘spot fixing’ a mobility network isn’t a thing. One fixes a route, for a vehicle class, at minimum ‘legs’ is a vehicle class, and ‘the other side of the street’ is a valid route, but most trips will include at least a few junctions in sequence. This treatment is best applied to junctions in sequence, a little of the video I have shows an adjacent junction a block away I fixed. I think three fixed junctions in a row is a nice thing, so doing two in a row is getting close. To appreciate three of these in a row starts with experiencing one. ↩

Weather as a Service

mbutler — Tue, 09 Dec 2025 05:05:20 GMT

Weather as a Service provides on-demand weather for fantasy role-playing games. It adapts the World of Weather appendix from Wilderness Survival Guide into a service that produces conditions such as clear days, storms, fog, and seasonal variation. The system uses the original tables and logic, with minor adjustments for presentation. Instead of consulting a book […]

Designing for Multiplayer Before You Need It

RobKohr's Blog — Tue, 09 Dec 2025 02:00:00 GMT

Designing for Multiplayer Before You Need It

Quality Fortress

june.kim — Tue, 09 Dec 2025 02:00:00 GMT

(12-9-2025) How to Find Flicker Free LED Christmas Lights

winrickLabs Blog — Tue, 09 Dec 2025 02:00:00 GMT

(12-9-2025) How to Find Flicker Free LED Christmas Lights - Size: 1.4 kB. 1 min read

Emoji Book Synopses

taylor.town — Tue, 09 Dec 2025 02:00:00 GMT


🐒🦴➡️🛸🖥️🔴🚀🌌👁️⭐👶✨	2001: A Space Odyssey :: Arthur C. Clarke
👨🏻‍🌾🌾💰📈📉👩🏻❤️💪😤💔💀🌾	The Good Earth :: Pearl S. Buck
👽🛸💥🏚️☢️🔦🎒💰💀😱🙏🟡	Roadside Picnic :: Arkady & Boris Strugatsky
☯️💧🌊🔄💭❓💪=💧🔄❌✅♾️	Tao Te Ching :: Lao Tzu
🌶️👨🏻🎺📜✍️😤🍩👩🏻‍🦳😩🎭🤡🌀	A Confederacy of Dunces :: John Kennedy Toole
👦🏻🧒🎮⚔️🧠💪📈👽😱😭💀	Ender's Game :: Orson Scott Card
🎮🎲🃏♟️🔍🧠🔀⚖️🤫👥🎨⚙️	Characteristics of Games :: Elias, Garfield, Gutschera
👩🏻💔🍷😵👨🏻🔬⚛️⏰🌍🔄❤️❓	Version Control :: Dexter Palmer
👨🏻💼😴🐛🦗😱👨‍👩‍👧🤢😢🍎💀	Metamorphosis :: Franz Kafka
🏠📏❓🌀👨🏻📖😵📐🚪∞💀🏚️	House of Leaves :: Mark Z. Danielewski
⛵🌊🏴‍☠️💰🏝️🥶💀💀😈📜⚖️❓	The Wager :: David Grann
🔢🎨🎵🧠🔁🐜🔁🧠💭♾️❓🪞	Gödel, Escher, Bach :: Douglas Hofstadter
🇨🇳🏭⚡🚄📈📈🇺🇸😰🏭📉🔧❓	Breakneck :: Dan Wang
🍞📈😵🥗📉😊✅🍽️🩸📉😊✅	Glucose Revolution :: Jessie Inchauspe
👁️🏛️😤🔄⏰👤❤️💔🧠🗑️😱❌	1984 :: George Orwell
⚡🔌🏭🏠💡☀️💨🔋📊😰🔄❓	The Grid :: Gretchen Bakke
👩🏻🔴⛓️🏛️✝️😱👶❓😤🤫🏃‍♀️❓	The Handmaid's Tale :: Margaret Atwood
👧🏻🐻❄️🔮😈⚔️👶🌌🚪👨🏻❤️💪	The Golden Compass :: Philip Pullman
👩🏻🏠🧱⏰🌍💥⚔️😶✍️📖🚪🔓	A General Theory of Oblivion :: José Eduardo Agualusa
🍎💻🎨😤💪📈📱🎵👨🏻🤒💀🌍	Steve Jobs :: Walter Isaacson
🎯❌🚶‍♂️🔀💡💎🧬🤖🎨🔬🗺️❌	Why Greatness Cannot Be Planned :: Kenneth O. Stanley & Joel Lehman
🚀👨🏻😵❓☀️📉👽🤝🧬⚗️🌍✅	Project Hail Mary :: Andy Weir
🏰👑💰⚔️🕷️🧠😱👥📈💔😱⚔️	The Dragon's Path :: Daniel Abraham
👨🏻💍👰😈🏴‍☠️⛓️💎🔓💰⚔️😤✅	The Count of Monte Cristo :: Alexandre Dumas
🏜️💧🏗️🇺🇸💰💪🌾🏙️📉😰❓😰	Cadillac Desert :: Marc Reisner
👨🏻🧠😢🌍👽🐷🗣️💀📖✝️🤝🔍	Speaker for the Dead :: Orson Scott Card
🎩✨🇬🇧📚👨🏻🆚👨🏻😈🪞🧚💀🌲	Jonathan Strange & Mr Norrell :: Susanna Clarke
✝️⏰👶🔙🌲⚔️👨🏻📖💔🤖🕰️😱	Hyperion :: Dan Simmons
🌵☀️🔫💀💀💀👨‍🦲😈⚔️🩸🌙💀	Blood Meridian :: Cormac McCarthy
👴🏻😈👨🏻❤️👨🏻🧠👨🏻✝️💰🔪❓⚖️	The Brothers Karamazov :: Fyodor Dostoevsky
🐭🧠📈👨🏻💉📖❤️💔🧠📉😢🐭	Flowers for Algernon :: Daniel Keyes
🤖☀️❤️👧🏻🤒🙏😢💔🏚️🌅👋😢	Klara and the Sun :: Kazuo Ishiguro
🦠😷💀🔬🔍📈💀💀👨‍🔬💪📉😢	Everything is Tuberculosis :: John Green
🛢️🌾💰🌍🤝😈💼🚢📈📉🎲💵	The World for Sale :: Blas & Farchy
🔬⚛️🔧🌍⚙️🏗️✅😤👥❌🔄❓	Radical Abundance :: K. Eric Drexler
👨🏻✍️📖👧🏻👦🏻🤼‍♂️🏠💔😂😢💀😭	The World According to Garp :: John Irving
🤡🎭⚔️💀🌍💥⏰🔙🏃‍♂️😈😊💀	Tyll :: Daniel Kehlmann
🏰🤵🏻📋😐👩🏻❤️💔🇬🇧😈🚗😢💭	The Remains of the Day :: Kazuo Ishiguro
💀😂😵🔄⏰⚔️✈️🏥😵😂💀🔄	Catch-22 :: Joseph Heller
⏰🚪👨🏻🔙👩🏻❤️🏛️😈💥🏃💔❓	Ministry of Time :: Kaliane Bradley
👧🏻👦🏻👧🏻🏫🎨❤️💔😢💉🫀😢💀	Never Let Me Go :: Kazuo Ishiguro
🌾🏔️🌍⚔️🦠🐄🌽➡️💪👑📖❓	Guns, Germs, and Steel :: Jared Diamond
🏠🌳✨🧩🔁🧩🏘️👥❤️✅🏗️♾️	The Timeless Way of Building :: Christopher Alexander
👶👶👶📊🧬👨‍👩‍👧😤📉😊📈✅😊	Selfish Reasons to Have More Kids :: Bryan Caplan
🎾🧠🧠😤💭🧠😤❌🧠✅💪🎯	The Inner Game of Tennis :: W. Timothy Gallwey
🧠😰⏰🧘‍♂️🌊🔄😌🎯❌💀🆓😌	The Wisdom of Insecurity :: Alan Watts
🔧🏭👤🏠🖨️✅💻🔧🖨️🏠👤✅	Fab :: Neil Gershenfeld
🐜🧠🌍💻🔬🏙️🧬⚙️🔄❓❓❓	Complexity: A Guided Tour :: Melanie Mitchell
👩🏻📱🤖😱📈🌍👀👑😤💔💥💀	An Absolutely Remarkable Thing :: Hank Green
👩🏻🕵️‍♀️🔍🌾🏕️😈👴🏻📜🧠⏰💥❓	Creation Lake :: Rachel Kushner
💰📈💥📉😭🌷🚂💻🔄⏰♾️😭	Devil Take the Hindmost :: Edward Chancellor
🧠💡💻⚛️💥😵👨🏻🎲🌍😱💭❓	The MANIAC :: Benjamín Labatut
🚀👽🎵✝️👥😊➡️😱💀💔😢❓	The Sparrow :: Mary Doria Russell
🔤📐🎨👁️🏗️📖📰🖥️🧠😊✅🔤	Thinking with Type :: Ellen Lupton
🌾🏔️🇺🇸👨‍👩‍👦‍👦❤️💔😈👦👦📖✝️🆓	East of Eden :: John Steinbeck
👦🏻🤒😢➡️💪😤👨🏻🤠🏔️📈🏛️👑	The Rise of Theodore Roosevelt :: Edmund Morris
👦🏻🏚️💔💊😢😤💪📉📈🏔️🌅❤️	Demon Copperhead :: Barbara Kingsolver
🔥🌍💧💰🏚️👩🏿✨🌱🚶‍♀️🤝📖✅	Parable of the Sower :: Octavia Butler
👸🏻💔🏰⛪👩‍👩‍👧‍👧🙏✝️💪🌳📜✍️	Matrix :: Lauren Groff
🏜️🌊💧🔮👨🏻⚔️🐛👑🌍⛏️💰🧪	Dune :: Frank Herbert
👦🏻⚔️🧙‍♂️🐜🐦🦅👑❤️💔😈💀😢	The Once and Future King :: T.H. White
🎪✨🖤🤍⚔️👩🏻🎩👨🏻🎩❤️😍♾️	The Night Circus :: Erin Morgenstern
👨🏿💔😢😤💪🏃‍♂️🏋️🧠📢💪💪💪	Can't Hurt Me :: David Goggins
💀❓😵🌍🔄⏰📉😱👥🥫💭❓	Ubik :: Philip K. Dick
👨🏻👨🏻🐰🏡💭👨🏻💪🧠❌🤝💔😢	Of Mice and Men :: John Steinbeck
🦎🌊🔍💰📈📈📈👥😰🌍💥😱	War with the Newts :: Karel Čapek
🐋⚓👨🏻🦿😤🌊⛵🔱💀📖😵🐋	Moby-Dick :: Herman Melville
👨🏻📰🎬📈😈💪🔪👑💰😐💔😢	What Makes Sammy Run? :: Budd Schulberg
🌍🚀👥😴🕷️🧬📈🧠🏙️🤝🌌❤️	Children of Time :: Adrian Tchaikovsky
📚🏛️🔮😈👨🏻➡️👼📖💀😱😈💭	The Library at Mt. Char :: Scott Hawkins
🎉💰👨🏻👁️💚🌊👩🏻💛🚗💀😢💚	The Great Gatsby :: F. Scott Fitzgerald
⏰🔀💥🏙️🔥👽💚👨🏻😐💀🔄😐	Slaughterhouse-Five :: Kurt Vonnegut
👨🏻🙏🚶‍♂️💰👩🏻😤🌊💭🧘‍♂️😌☯️✨	Siddhartha :: Hermann Hesse
🌍✨🚀🧪💊😵😊❓💭😊=💊😵	Brave New World :: Aldous Huxley
🏛️🌊🗿👨🏻📝😊🐦💀🧠🔓🌅❤️	Piranesi :: Susanna Clarke
🏭🏛️⚙️🤖⛵💡🔄⏰😤❌✅📖	Men, Machines, and Modern Times :: Elting E. Morison
💰🏜️😈🔫💀💀💀👨🏻🏃‍♂️👮‍♂️😢👴🏻	No Country for Old Men :: Cormac McCarthy
💻🧠👨🏻🔬🏛️💰📈🖥️🌐🧠💡💻	The Dream Machine :: M. Mitchell Waldrop
💡🧊❄️➡️🏙️🔊📻💧🔦📺🌍🔄	How We Got To Now :: Steven Johnson
👶🏽🏚️🏙️📈💰💧👩🏽❤️💔👑💀❓	How to Get Filthy Rich in Rising Asia :: Mohsin Hamid
🌍🐢🐘🧙‍♂️😵🧳🏃‍♂️💨💀😂🌍🔮	The Colour of Magic :: Terry Pratchett
🐷🐴🐓⚔️👨‍🌾✅🐷👑📈😤🐷=👨‍🌾	Animal Farm :: George Orwell
🗺️🏔️🌊🏜️🇷🇺🇨🇳🇺🇸💪⚔️💰👑	Prisoners of Geography :: Tim Marshall
🏠🔄⏰👨🏻👨🏻👨🏻💛🦋😈🌧️🌧️😢	One Hundred Years of Solitude :: Gabriel García Márquez
🎮🧠👨🏻💪🚀🌍👽⚔️👑😤✅	The Player of Games :: Iain M. Banks
🌍➡️🌍➡️🌍♾️👨🏻🚶‍♂️👥🔄😊😰	The Long Earth :: Baxter & Pratchett
🚀⚔️🌌😈🤖🏛️🆚🔍💎💀💀💀	Consider Phlebas :: Iain M. Banks
🔥🌍💀🌫️👨🧒🛒🥶😈🔪❤️🌊	The Road :: Cormac McCarthy
🇬🇧👨‍👩‍👦‍👦👨‍👩‍👧‍👦🔄⏰🇧🇩🇯🇲🤝😤😂😢	White Teeth :: Zadie Smith
🌌❄️🚀💻🍕⚔️🏍️🧠💊😵🦠🗡️	Snow Crash :: Neal Stephenson
👨🏽‍⚖️📜🏙️⚖️😵💔💰💎🏃‍♂️💥😱	A Naked Singularity :: Sergio de la Pava
📖🤖🧒👧🏻🧠📈📈📈🌍🏙️💰💪	The Diamond Age :: Neal Stephenson
👨🏻🎓❤️👩🏻💔😢💀👩🏻❤️🌲🍂💭	Norwegian Wood :: Haruki Murakami
⚡🧪👨🏻🔬🧟💀😱🏃‍♂️❄️👰💔😢	Frankenstein :: Mary Shelley
❄️🌍👨🏻👤❓♀️♂️🔄🏔️🤝❤️🌨️	The Left Hand of Darkness :: Ursula K. Le Guin
💀⚔️👩🏻‍🦰👩🏻📚🏰🔮😈💥❤️😭💀	Gideon the Ninth :: Tamsyn Muir
👨🏻🔧🏍️🔄🌍💭🔧=🧘‍♂️=❓💭🧠	Zen and the Art of Motorcycle Maintenance :: Robert Pirsig
🎮👩🏻👨🏻🤝❤️💻📈😊💔😤🔄	Tomorrow, and Tomorrow, and Tomorrow :: Gabrielle Zevin
🌍💥🔥😱👩🏽🔮💪😤👧🏽🔍❓⛓️	The Fifth Season :: N.K. Jemisin
🌊🚣‍♂️🌫️👴🏻⏰🔄😶💭🌅❓💀🌊	A Shining :: Jon Fosse
🧛‍♂️💀❤️💔⏰♾️😢🧛‍♂️👧🏻😤💭🌙	Interview with the Vampire :: Anne Rice
🏛️👁️📊🌳➡️🌲🌲🌲👥😰💔❌	Seeing Like a State :: James C. Scott
🏚️🌾💨😢👨‍👩‍👧‍👦🚗➡️🌅🍊💰❌✊	The Grapes of Wrath :: John Steinbeck
🚀👥🤖📋👤❓🤖❓👤🤖❓🚀	The Employees :: Olga Ravn
🌊🧠👽❓👨🏻🔬😵👩🏻💀😱😢💭	Solaris :: Stanislaw Lem
👴🏻🧠💭🌍❓💥➡️🔄💭🌍=❓	God's Debris :: Scott Adams
🇺🇸🏭🚗💰🤪📖✍️👨🏻‍🦳🎭🤡😂😢	Breakfast of Champions :: Kurt Vonnegut
⚡🔥🌡️🔬⚙️1️⃣2️⃣3️⃣🔄❄️💀❌	Three Laws of Nature :: R. Stephen Berry
👧🏻✍️💋😱💔⚔️💀👩🏻😢📖😭❓	Atonement :: Ian McEwan
🏭🤖⚙️👷❌👨‍💼✅😐😢🍺✊💥	Player Piano :: Kurt Vonnegut
💻🧠🌃💉👨🏻🔓🤖👁️🛰️🔀💀✨	Neuromancer :: William Gibson
👦🏻⚔️🩸🏔️🧘‍♂️📈💪👩🏻❤️🎨👑😌	Musashi :: Eiji Yoshikawa
🧠💡🔬😵💥🌍😱🧪👨🏻🤯💭❓	When We Cease to Understand the World :: Benjamín Labatut
💻🔧👥😤☕🌙💪📈📈📈✅🏆	The Soul of a New Machine :: Tracy Kidder
👨🏻🧠⚛️🔬💡📈🤫😶🧠⚛️💡🤫	The Strangest Man :: Graham Farmelo
🚀👽🧠½😱👁️👁️👁️💀🌍🧠❓	Blindsight :: Peter Watts
🌽🍔🌾🐄🍽️❓🏭😰🌳🍄🔫✅	The Omnivore's Dilemma :: Michael Pollan
✈️👩🏻🇬🇷👂🗣️👥💭😶📖❓👤	Outline :: Rachel Cusk
👩🏻🏪😊👥😤❌🏪✅😊👥😤❓	Convenience Store Woman :: Sayaka Murata
👵🏻😤💔🏘️⏰🔄❤️😢👥🌊💭	Olive Kitteridge :: Elizabeth Strout
🌌⏰♾️👯‍♀️🚀🌍❤️😈🔫💀🔄🌌	House of Suns :: Alastair Reynolds
🎾🏥💊📺♾️👨🏻😢👨🏻😢🎬💀🔄	Infinite Jest :: David Foster Wallace

Generated with Claude, from my book list.

Join the on-call roster, it’ll change your life

SerCe's blog — Tue, 09 Dec 2025 02:00:00 GMT

Joining an on-call rotation might change the future of your career – and maybe you as a person. This article shares my experience being on-call.

UC AI v25.7: Embeddings, xAI, OpenRouter and Toon

Philipp Hartenfeller Blog RSS Feed — Tue, 09 Dec 2025 02:00:00 GMT

The current UC AI release adds support for xAI (Grok) and OpenRouter (almost all models). Additionally, embedding is supported for all providers, you can use Toon, and override URLs for all providers.

Shell Permission Errors for Busy Coding Agents

David Buchanan's Blog — Tue, 09 Dec 2025 02:00:00 GMT

Recursive Self-Improvement Regime (125)

Artificial Insights — Mon, 08 Dec 2025 20:54:09 GMT

Welcome back to Artificial Insights, Carol.

Manuel was annoyed

Annoying Technology — Mon, 08 Dec 2025 20:49:11 GMT

All three of the files on top have been created/exported/transferred in the exact same way: Exported from the recently discarded (severely underrated, btw) Clips app, then sent (all in one transfer) via AirDrop. How on earth is it possible for them to have different cases on the file extension?!

Developing a food-safe finish for my wooden spoons and cups

Copper • A blog about conductive layers — Mon, 08 Dec 2025 18:16:44 GMT

You know what they say in the world of products: fast, cheap, good; pick two

Which is very similar to my experience when trying to find the most suitable wood finish for my hand carved wooden spoons and coffee cups.

hand carved wooden spoon

It’s hard to find a finish that:

cures fast (in less than 2 days)
is food safe (can be used on things you eat or drink from, like spoons and cups)
is free of solvents (doesn’t smell of nasty chemicals that make you dizzy every time you apply it)
and with the hard requirement of making wood hydrophobic and leaving a visually pleasant sheen without creating a plasticky layer

Natural drying oils

Sure, we have pure tung oil which doesn’t need any solvent, has a pleasant nutty smell, and cures into a food-safe hydrophobic polymer inside the wood fibers. But it takes 2 to 4 weeks for the curing to happen depending on oxygen intake, and the finish is quite matte and boring.

While tung oil is natural, that doesn’t mean you can ingest it. It is a powerful irritant in its liquid form, it is only food-safe after curing into its inert polymer state.

There’s also the more rare polymerized (or heat-bodied) tung oil, which is a honey-like viscous oil that cures in a few days because it was heated to very high temperatures in the absence of oxygen. That would be ideal except I can’t find it anywhere around me to buy, and it would most likely need thinning with citrus oil solvent (or D-limonene).

Citrus oil has a nice but way too potent smell of orange peel. It might seem pleasant at first compared to the chemical smell of naphtha and white spirits, but it can be too much if you finish small wooden objects often like I do.

ash cup, in the process of being oiled with tung oil

And there are plenty other drying oils, the most well-known being linseed oil, which is indeed edible but has the unfortunate disadvantages of yellowing over time, taking ages to cure and having a persistent oily-grassy flavor. Polymerized linseed oil (aka stand oil) cures faster but still retains the nasty flavor.

Careful not to confuse it with boiled linseed oil or BLO, which uses metallic drying agents like cobalt or manganese salts.

The boiled name comes from the old practice of heating the linseed oil with lead oxide inside, effectively shortening the oxidation process. But nowadays there’s no heat involved in BLO.

More details in The lowdown on BLO

The oil painting world has experience with many drying oils like safflower oil, walnut oil, poppy seed oil, hemp seed oil. Unfortunately they cure slower and into a less durable film while also being rare and expensive so they aren’t good alternatives for wooden utensils.

Hardwax oils

For a good few months I used Osmo Polyx Oil which is a solvent-based hardwax oil. Its safety datasheet and full declaration of ingredients mention about 50% of it being white spirit solvent, and the rest is composed of natural oils processed to become drying oils, and a small amount of hard carnauba wax.

It is fast curing in less than a day, leaves a beautiful shimmer on the wood surface, it is food safe after curing, but smells awful because of the solvents.

In the winter months I carve indoors and have to finish the pieces indoors as well, and the horrible solvent smell fills my house for a whole day. I seem to have become sensitized to the smell and now I have almost a full can of Osmo that I can’t use without a mask, even outdoors.

Rubio Monocoat two-component hardwax oil on a half finished wooden board

There’s also Rubio Monocoat and other two-component hardwax oils where the base component is usually a solvent-free blend of drying oils and waxes, and the accelerator component is Hexamethylene diisocyanate or HDI. The base component can cure on its own in about 3 weeks and the accelerator shortens the curing time to less than a day.

This alternative cures fast into an inert and food safe polymer, smells like apple pie, and the finish has a slight satin effect. But it’s really hard to mix properly and apply on small wooden objects like spoons and cups. I almost always use too much accelerator, the mixture ends up too viscous and hard to spread on the wood and the constant opening of the bottles and cans makes the components dry prematurely in their containers.

However, this idea of blending drying oils with hard wax seems to be promising and it’s the path I continued on developing.

Notable mentions

Food-safe epoxy is another alternative, but I hate both the idea of using synthetic plastics and their plasticky look takes away from the experience of using wooden utensils.

Why even use wood if you’re going to cover it in a layer of clear plastic?

Many people also recommend other edible oils like coconut oil, olive oil etc. But these don’t cure and don’t provide any protection for hot liquids. They either go rancid inside the wood fiber or get washed out after using the wooden object.

Some recommend non-edible petrol-based mineral oil (aka liquid parrafin) because it doesn’t go rancid, but has the same effect of not actually doing much for protection and will leak into hot liquids.

Beeswax is often used by kuksa makers (traditional Scandinavian wooden cups) but wax molecules are too large to penetrate wood fibers well, and it has a low melting point of 60℃ (140°F) so hotter liquids are out of the question.

Carnauba wax has a higher melting point at 80℃ (176°F) and is harder than beeswax, but it has a glossy finish, having a similar look to epoxy resin after buffing.

The ideal finish should combine the durable hydrophobic properties of fiber-penetrating tung oil with the fast drying properties of a top wax layer, in an easy to apply but solvent-free blend.

Urushi

wooden spoons finished with urushi lacquer

Some carvers use urushi lacquer which is the sap from a tree common to Japan. The result is a hard and glossy finish that can resist temperatures of over 300℃ (572°F), but the look and process of application is far from what I’m looking for.

To ensure curing is complete, it needs 10 to 20 very thin coats over many months in a warm and humid environment. The wood then takes this dark brown color, regardless of what wood you started with, which is the opposite of what I want.

I work with fruit and flower woods that are less common in woodworking (apple, fig, jasmine etc.) and I want people to know that and experience what that specific wood looks and feels like. I want to keep their original hues and tints and accentuate the wood grain of each piece.

fig wood spoon between other hand carved spoons

Someone from Israel bought a spoon I made from fig tree wood, but still asked about it a bit incredulously. It had greenish light wood grain, with a bit of untouched bark kept on the handle and a wonky curve that followed the shape of the tree branch it was made from.

They have many fig trees there but had never seen such a thing made from their wood, so they felt a connection to their motherland in that usual object.

lilac coooking spoon, front and back

My mother-in-law cut a large lilac tree and gave me some thick branches. It’s a wood that cracks very easily while drying, and I couldn’t use most of it. But the few things I made from it, I gifted back to my wife’s mother and sisters in the form of cooking spoons and are still cherished by them today.

Its pastel purple grain accents remind them clearly of the tree that used to flower every spring in their yard.

A brown lacquer would never be able to create this effect, and that is why I’m still trying to find the perfect natural oil based finish.

Hassui Ceramic (or liquid glass)

This is basically polysiloxane dissolved in alcohol and isoparaffin solvent. After 3 weeks it cures into a food-safe, hydrophobic layer which is durable, but not very good looking in my eyes.

It leaves the wood looking bare, without the color enhancing and rippling effect of oil. Some might prefer that, especially people that worked hard on getting a very shiny knife finish on their carving.

In my case, this is not the finish I’m looking for because of the 3-week curing time, the solvent-based solution, the colorless look and the fact that this finish is very expensive and hard to find outside Japan.

Here’s some more information from a woodturner’s experience with the finish: Liquid Glass Wood Finish – Update

Natural hardwax oil

For the impatient, here’s a comparison video on how the hardwax oil blends look and perform in a water test on some plum wood blanks.

My experiments started simple, with melting about 10g of carnauba wax flakes into 40g of pure tung oil.

Tung oil and carnauba wax flakes

Most people recommend a double-boiler or bain-marie approach to melting the wax. That’s because the heat source would be a container of boiling water which can never get above 100℃ (212°F), a safe temperature to avoid reaching the flash point of these oils.

I just drop a spoonful of carnauba flakes into a glass jar of tung oil and place it in the microwave for a minute until everything becomes liquid.

For small quantities, the microwave works wonders, and there’s no danger of overheating the oil or gelifying it because it cools off rapidly.

experiment #1

Ingredients:

40g pure tung oil
10g carnauba wax flakes

Process:

pour the tung oil into a glass jar or ceramic container
drop the carnauba wax flakes into the oil and stir to disperse the flakes
place in the microwave for 30 seconds then stir again for a few seconds
repeat until the wax melts and everything is liquid
let it cool down until the mix is solid

Result:

Brittle paste that’s hard to scoop from the jar and apply on the wood. Doesn’t spread easily, feels sticky.

After the whole wood surface was covered and left for 10 minutes, the excess was wiped with a paper towel. After wiping, the finish is very matte, which means that not much of the wax remained, and the oil didn’t penetrate the fiber enough because of the consistency.

Smells nice though.

Improving the consistency

The consistency changes a lot based on the oil-to-wax ratio.

Too much wax and the blend cools into a brittle paste that’s very hard to scoop from the jar. Too little and the blend is too liquid with not enough wax remaining on the wood surface to form a film. A 4:1 oil-to-wax ratio is good, having enough wax for the top layer, but in this simple formulation it is still too hard and brittle.

Instead of increasing the oil quantity which could defeat the purpose of the wax layer, I added a bit of beeswax to soften the blend.

This works, the paste becomes softer but it makes the top layer of wax not durable enough because of its lowered melting point, so I needed an alternative.

My idea is to have the wood absorb the tung oil from the blend while leaving the wax molecules on the wood surface. The wax should be soft enough to not create a glossy layer and not be brittle, but hard enough to protect the wood for the time it takes the tung oil to cure.

experiment #2

Ingredients:

40g pure tung oil
7g carnauba wax flakes
2g beeswax
1g lanolin

To soften the blend without having to add too much beeswax, I found lanolin to be a good addition. It is a highly hydrophobic wax extracted from sheep wool that even in tiny amounts can make the paste consistency softer and easier to apply.

Process:

Similar to #1, just immerse the waxes into the oil in a glass jar and microwave in increments of 30 seconds until everything is liquid. Leave to cool until solid.

Result:

Softer and more homogenous paste that can be scooped easily from the jar with a finger or rag. Spreads relatively easy onto the wood surface, feels like a more viscous hand cream.

Smells amazing, nutty, vanilla and honey scent, faint enough to not bother anyone.

After covering the whole wood surface, I used a heat gun to liquify the finish and enhance wood fiber penetration. The paste melts very easily and the oil in it gets absorbed quickly in the wood pores, leaving the wax to solidify.

After the wood has cooled, I applied another layer because it seemed that some parts of the wood had little to no wax remaining. I removed the excess with a paper towel and buffed the wax to a satin look.

small issues

curing speed

This finish is not fast curing by any means. It is fast drying, as the oil gets absorbed and the wax on top solidifies into a very thin medium-hard layer.

But the melting point of the wax is about 75℃ (167°F) so still not perfect for very hot liquids. You definitely can’t brew your tea directly into a cup finished this way, not until the oil cures completely after 2-4 weeks.

I tested it by brewing a cup of espresso which seems to be fine, the temperature of the coffee is far below 75℃ (167°F) when it reaches the cup.

Using a spoon for eating soup also works fine, because the soup needs to be below 45℃ (113°F) for me to be able to eat it.

olive wood spoon with hydrophobic layer

sycamore coffee cup with hydrophobic layer

After usage, the wooden spoon and cup could be easily washed with warm water and soap, the wood didn’t stain at all. The wax still worked as I could see the water droplets sliding off the wood.

sheen and appearance

Visually, it doesn’t leave a very strong sheen. It has a soft waxy look, instead of the shimmer of oiled wood.

That’s because wax doesn’t follow the micro porous surface of the wood, it solidifies into a smooth surface. So instead of scattering light you get mirror-like reflections creating that glossy wax look.

Commercial finishes use flattening agents like fumed silica to get around this, but I’m trying to use as little additives as possible for now.

The look also comes from the carnauba wax being softened by the beeswax and lanolin which also translates into a softer top layer.

natural resins

The woodworking world has moved on almost completely from natural resins. Almost every finish is either based on polyurethane or epoxy resin if you’re looking for a harder top layer. At best, you’re looking at a shellac layer which doesn’t mix with oils.

Thankfully oil painting forums and blogs still have a trove of information on tree resins, drying oils and siccatives.

damar resin crystals

That’s how I found out about damar resin, a semi-hard resin extracted from Dipterocarpaceae trees growing in southeast Asia. It is a clear resin, melts at about 120℃ (248°F) which is easily attainable in a microwave, and has a bit of flexibility so that it doesn’t create a cracking layer on wood.

It can be found in the form of crystals or pellets in art shops and it’s pretty cheap. People dissolve it in turpentine to create varnishes, but I wanted to incorporate it into my oil-wax blend through heat instead of solvents.

experiment #3

Ingredients:

50g pure tung oil
10g carnauba wax flakes
2g beeswax
2g lanolin
3g damar resin
5g coconut oil
2 drops of MnZrCa drier
2 drops of vitamin E

To increase sheen and make the top layer stronger, I melted damar resin crystals directly into oil, without any solvent. I also added a very small amount of manganese, zirconium and calcium drier to make the curing faster, and some vitamin E to increase shelf life.

Process:

Add the carnauba wax, beeswax and lanolin into the tung oil in a glass jar and microwave in increments of 30 seconds until everything is liquid.

Add the damar resin crystals into the coconut oil and microwave in increments of 10 seconds until everything is liquid. Let the mix cool down for about 30 seconds then add the drops of MnZrCa drier and vitamin E. Stir until the mix is homogenous.

Pour the damar resin-oil blend into the tung oil blend and stir until homogenous. Let cool down until solid.

Result:

Medium-soft paste that can be scooped relatively easily from the jar with a finger or rag. Spreads easy enough onto the wood surface.

Smells the same as the last experiment: nutty, vanilla and honey scent, faint enough to not bother anyone. The nasty smell of the drier doesn’t transfer into the blend because its quantity is too small. The resin has no smell in its solid form.

After that there was almost no excess left and I buffed the top layer to a satin look using a paper towel.

Curing:

The tung oil inside the wood cured in about 48 hours.

This can be verified by melting the wax layer with a heat gun then removing the liquid wax with a rag. The bare wood then can be sanded with 240 grit to check if the wood dust falls off easily. If the wood dust seems wet and gums on the sandpaper, the oil is still not completely cured.

Look:

The satin sheen looks better because of the resin. Regions with medullary rays look wavy and move in the light, regions with straight fibers look exactly between glossy and matte.

Osmo Polyx Oil still has a prettier shimmer that this finish doesn’t achieve, I’ll look into adding trace amounts of fumed silica to see if it makes the finish settle better into the wood fiber microstructure and scatter light instead of being more on the smooth glossy side.

The fumed silica might also help with adding shear thinning capability so that the paste is even easier to scoop from the jar without softening it.

notes on added ingredients

metallic driers

The metallic driers are probably the first thing that jump out, because we always read about how bad they are when seeing people talk about natural wood finishes. Not all driers are bad, and it depends on things like quantity, leaching probability and type of metal used.

Sure, lead and cobalt driers are out of the question, I don’t want them anywhere near my food and beverages no matter how small the risk of leaching. They contain heavy metals that can have catastrophic effects if they accumulate in your body.

I use a drier containing manganese neodecanoate to speed up surface-drying, and zirconium and calcium salts for through-drying.

Zirconium and calcium are known to be safe. Zirconium is the same metal that dental implants are usually made of, even ceramic knives are made using zirconium, it seems to be a pretty inert metal when it comes to contact with our body.

Manganese is toxic if inhaled or ingested in high amounts, but the quantity of manganese in 2 drops of drier is so incredibly low you could take them orally and not feel any effect other than the horrible solvent taste. That, combined with the fact that the drier disperses throughout the oil makes the quantity too low to matter.

The strictest Tolerable Upper Intake Level for manganese is set to 8 mg/day. In fact we get some of that quantity daily through food that is enriched with vitamins and minerals. If the drier were to ever leach completely from the finish, one would get less than 0.1mg per lifetime of object.

You’d probably have to eat the spoon completely for that to happen, in which case the quantity of ingested wood might become more of a problem.

But the whole food-safe standard on drier based finishes is actually based on the fact that a cured finish traps that metal into an inert polymer which can’t leach into food. Just like Teflon pans or aluminum and copper pots, everything is safe until the layer chips off somehow.

I compromised on having a quantity small enough to not pose any safety risk and that wouldn’t shorten shelf life by making the oil cure inside the jar, but high enough to make the oil cure in 48 hours instead of 2-4 weeks. This, in my opinion, makes the finish safer by being more predictable in curing time, and minimizing the probability of food contacting uncured tung oil.

coconut oil and vitamin E

Because damar resin melts at 120℃ (248°F), tung oil is not suitable for melting the resin directly into it because tung oil can gelify at high temperatures, hindering its curing capabilities. That’s why I melt the resin crystals in a small amount of coconut oil, which has a high enough smoking point of 180℃ (356°F), smells amazing and doesn’t go rancid easily.

oil smoke point chart

I added 2 drops of vitamin E (aka tocopherol) because it is a powerful antioxidant and will lower the chance of ingredients like coconut oil going rancid. It can also lower the chance of the tung oil curing inside the container by inhibiting the autoxidation reaction.

This is the current formulation that I’m using for finishing my wooden spoons and cups, and which I’m selling on my online shop in Romania.

Comparison video

In the following video, I applied the 3 experiments on some plum wood blanks, sanded to 600 grit and water popped 3 times.

In total I had 7 blanks:

experiment #1
experiment #2
experiment #3
unfinished wood
Osmo Polyx Oil
raw tung oil
raw tung oil with drier

After applying the finishes, I left them for 24 hours to cure indoors at 22℃ (72°F) at 50% humidity, then sprayed them with water to see how the water beaded up on the surface.

Comparison between hardwax oil blends

Conclusions:

Osmo Polyx still creates the highest sheen, but felt a bit too glossy on this specific wood, not sure why. I actually liked the damar resin and drier blend the most.

Osmo contains titanium dioxide to whiten the finish a bit, and it also contains more refined oils, so the wood colors looked less saturated. I guess that’s good if you want to keep a light wood from getting a yellow tint, but on my spoons and cups I very rarely need that, so I like the colour imparted by the tung oil.

Water beaded up on all finished blanks and was absorbed by the unfinished wood instantly as expected. Osmo and our #3 blend had the largest water beads.

After cleaning up the water with a paper towel and letting the wood dry, the first two blends lost their sheen and colour almost completely and felt less smooth to the touch. The damar resin and drier really did their job in the third blend.

The tung oil only blank felt the roughest after drying, the oil only created a very weak hydrophobic layer because it couldn’t cure after 24 hours. The blank with the drier added felt smoother, but still absorbed a bit of water. It needed more layers and more time to get full fiber saturation.

experiment #4

to be continued…

Sunday School: Drop In, Vibe On

Eleanor on Everything — Mon, 08 Dec 2025 13:29:57 GMT

Let's get everyone building with agentic AI

Tag Kinds in OpenAPI 3.2

LornaJane — Mon, 08 Dec 2025 10:32:32 GMT

OpenAPI tags have always been annoying: user-supplied arbitrary data for endpoints should be a fabulous feature – but the documentation tools seem to think that tags are only for them so it becomes more difficult to use tags for other … Continue reading →

What We Take For Granted

sin-ack's writings — Mon, 08 Dec 2025 10:30:00 GMT

This is the lightning(-ish) talk I gave at TigerBeetle 1000x World Tour Belgrade, transcribed to article form. Huge thanks to Ludwig for hosting the event and the TigerBeetle folks for setting it up.

The slides are available in PDF format as well.

The Bird-Poker Deck

Send More Paramedics — Mon, 08 Dec 2025 10:07:49 GMT

Whereby I talk about turning a common American Checkers set into an "arcade" for deep games of abstract strategy.

swipefeed

Brian Sunter — Mon, 08 Dec 2025 06:52:27 GMT

Headless React primitives for building TikTok and Reels-style swipe feeds: a render-prop component and hook with virtualization, gestures, keyboard, and accessibility built in.

Learning from Gary vol. 1

Something About Cats — Mon, 08 Dec 2025 04:06:03 GMT

On turning left

New Search Filtering in Web and API

Weblog on marginalia.nu — Mon, 08 Dec 2025 02:00:00 GMT

The search engine recently exposed a fair number of new tools for custom filtering to the API consumers and users of the new UI.

This was originally going to be an incredibly chaotic update, both annuncing the new features and doing a technical walkthrough of the changes but that ambition turned out a bit too chaotic, so let’s split them up and focus on the feature announcement bit today.

New Search Filtering GUI

It’s now possible to define a custom filter in the GUI, on the marginalia-search.com version of the website!

Review: a bookmarklet to generate coding agent-ready code reviews

N=1 (marcua’s blog) — Mon, 08 Dec 2025 02:00:00 GMT

I’m excited to share Review, a bookmarklet that makes it easier for you to code review AI coding agents. The bookmarklet turns all unresolved comments on a GitHub pull request into a Markdown-formatted text blob that you can paste into your coding agent of choice. Since a video is worth a thousand words, here’s the tool in action with Claude Code:

I read 'Gentleman Jim' by Raymond Briggs

cjlm.ca — Mon, 08 Dec 2025 02:00:00 GMT

Interesting Books I’ve Read in 2025

Brett Mullins — Mon, 08 Dec 2025 02:00:00 GMT

Below are some interesting books I’ve read in 2025. This year’s list is topically wide-ranging: from the mathematics of data privacy and information theory to the history of economic thought, from early analytic philosophy and contemporary metaphilosophy to weird fiction, and even an early nineteenth-century meditation on the art of eating well. If you have some thoughts on my list or would like to share yours, send me an email at brettcmullins(at)gmail.com. Enjoy the list!

Kong + CUE

Brian's Waste of Time — Mon, 08 Dec 2025 02:00:00 GMT

Kong is my go-to CLI parser in go, so I used it for epithet. It has pretty good built-in configuration handling, I appreciate how it lines up config values with CLI flags by basically treating config as a serialized tree of it's structs. This is great for simple things, but for epithet I needed slightly more complex mapping, with dynamic keys (user identities) and such. I wanted to keep the core of its model though as it's really nice.

So, I wrote a thing to configure it using CUE. CUE seems complicated if you read its docs, because it dives straight into it's prolog-y evaluation roots, but you can basicaly ignore that for simple use cases (and then use it for hairy ones). It turns out I really liked this, so extracted it to a library, meet kongcue.

It works mostly like the built-in Kong config mechanism, except it happily handles YAML, JSON, and CUE syntax, unifies across multiple files elegantly, and allows me to treat validation issues as configuration issues (with useful error messages, lone and column pointers, etc) if you use a config file, or fallback to kong's flag based errors if you don't use a config file. It can also simply generate a CUE schema file for artbitrary config documentation and validation!

Example time! Let's take a small hello-world style kong app:

package main

import (
	"fmt"

	"github.com/alecthomas/kong"
	"github.com/brianm/kongcue"
)

func main() {
	var c cli
	ktx := kong.Parse(&c, kongcue.AllowUnknownFields("messy"))
	ktx.FatalIfErrorf(ktx.Run(c))
}

type cli struct {
	Name      string            `default:"world" help:"The name of the person to greet"`
	Stuff     bool              `required:"" help:"A required flag, about stuff"`

	Greet     GreetCmd          `cmd:"" help:"Issue a greeting"`
	Depart    DepartCmd         `cmd:"" help:"Issue a valediction"`

	Config    kongcue.Config    `default:"./example.{yml,json,cue}" sep:";" help:"Config file paths"`
	ConfigDoc kongcue.ConfigDoc `cmd:"" help:"Print config schema"`

	message string
}

type GreetCmd struct {
	Excited int `default:"0" help:"How excited are you to see this person?"`
}

func (g GreetCmd) Run(c *cli) error {
	// elided
}

type DepartCmd struct {
	Sadness int `help:"How sad are you to be leaving?" required:""`
}

func (g DepartCmd) Run(c *cli) error {
	// elided
}

It has a couple sub-commands, some flags, all of it is just demo-ware. Note the lines:

	Config    kongcue.Config    `default:"./example.{yml,json,cue}" sep:";" help:"Config file paths"`
	ConfigDoc kongcue.ConfigDoc `cmd:"" help:"Print config schema"`

These set up configuration handling, and a sub-command to dump the schema and documentation! This does what it looks like, globs across the possible config file names, loads all that match, etc. The schema part is nifty, as it generats config docs, effectively. Invoke example config-doc and you get:

// Configuration schema for validating config files.
//
// This schema is written in CUE, a configuration language that
// validates and defines data. Learn more at https://cuelang.org
//
// To validate your config file against this schema:
//   1. Save this schema to a file (e.g., schema.cue)
//   2. Run: cue vet -d '#Root' schema.cue your-config.yaml
//
// Fields marked with ? are optional. Fields without ? are required.
#Root: close({
	// The name of the person to greet
	name?: string
	// A required flag, about stuff
	stuff: bool
	// Issue a greeting
	greet?: #Greet
	// Issue a valediction
	depart?: #Depart
	messy?:  _
})
#Depart: close({
	// How sad are you to be leaving?
	sadness: int
})
#Greet: close({
	// How excited are you to see this person?
	excited?: int
})

While this is a bit obscure, it is not that hard to follow even if you are not familiar with CUE's schema/constraint declarations.

If you invoke it with a bad config file, you get a nice config error:

kongcue/example on  main ❯ cat bad.yml
name: "test"
stuff: "walrus"
kongcue/example on  main ❯
kongcue/example on  main ❯ go build && ./example --config ./bad.yml
example: error: stuff: conflicting values "walrus" and bool (mismatched types string and bool):
                    /Users/brianm/src/github.com/brianm/kongcue/example/bad.yml:2:8
kongcue/example on  main ❯

Without a config file (default is not present, none specified) it gives you CLI oriented errors:

kongcue/example on  main ❯ ./example
example: error: missing flags: --stuff
kongcue/example on  main ❯

It has a simple escape hatch for non-CLI compatible config sections, which you see in the above example:

	ktx := kong.Parse(&c, kongcue.AllowUnknownFields("messy"))

This allows the messy thing in the example config, even though it does not appear in the kong struct tree.

name: "Brian"
stuff: true
depart:
  sadness: 3
messy:
  woof: "meow"
  splat: 7

The kongcue.AllowUnknownFields("messy") tells it to just accept anything in the messy value. At some point I'll add a mechanism to define a schema for these, but for now it just relies on deserializing to structs erroring out.

The cue.Value for the config tree is made available as a kong binding, so you can get it in whatever command you need to pull additional values from. This allows epithet policy configs like:

users:
  alice@example.com: [admin, eng]
  bob@example.com: [eng]
  charlie@example.com: [ops]
  diana@example.com: [admin, ops]

which can be defined nicely in CUE, but not naturally kong's cli constraints.

For a more complex, and real, schema generated from epithet, take a look at epithet's:

// Configuration schema for validating config files.
//
// This schema is written in CUE, a configuration language that
// validates and defines data. Learn more at https://cuelang.org
//
// To validate your config file against this schema:
//   1. Save this schema to a file (e.g., schema.cue)
//   2. Run: cue vet -d '#Root' schema.cue your-config.yaml
//
// Fields marked with ? are optional. Fields without ? are required.
#Root: close({
	// Print version information
	version?: bool
	// Increase verbosity (-v for debug, -vv for trace)
	verbose?: int
	// Path to log file (supports ~ expansion)
	log_file?: string
	// Disable TLS certificate verification (NOT RECOMMENDED)
	insecure?: bool
	// Path to PEM file with trusted CA certificates
	tls_ca_cert?: string
	// Start the epithet agent (or use 'agent inspect' to inspect state)
	agent?: #Agent
	// Invoked during ssh invocation in a 'Match exec ...'
	match?: #Match
	// Run the epithet CA server
	ca?: #Ca
	// Run the policy server with OIDC-based authorization
	policy?: #Policy
	// Authentication commands (OIDC, SAML, etc.)
	auth?: #Auth
})
#Agent: close({
	// Match patterns
	match?: [...string]
	// CA URL (repeatable, format: priority=N:https://url or https://url)
	ca_url?: [...string]
	// Authentication command
	auth?: string
	// Per-request timeout for CA requests
	ca_timeout?: int
	// Circuit breaker cooldown for failed CAs
	ca_cooldown?: int
	// Start the epithet agent
	start?: #AgentStart
	// Inspect broker state (certificates, agents)
	inspect?: #AgentInspect
})
#AgentInspect: close({
	// Broker socket path (overrides config-based discovery)
	broker?: string
	// Output in JSON format
	json?: bool
})
#AgentStart: close({})
#Auth: close({
	// Authenticate using OIDC/OAuth2 (Google Workspace, Okta, Azure AD, etc.)
	oidc?: #AuthOidc
})
#AuthOidc: close({
	// OIDC issuer URL (e.g., https://accounts.google.com)
	issuer: string
	// OAuth2 client ID
	client_id: string
	// OAuth2 client secret (optional if using PKCE)
	client_secret?: string
	// OAuth2 scopes (comma-separated)
	scopes?: [...string]
})
#Ca: close({
	// URL for policy service
	policy: string
	// Path to ca private key
	key?: string
	// Address to listen on
	listen?: string
})
#Match: close({
	// Remote host (%h)
	host: string
	// Remote port (%p)
	port: int
	// Remote user (%r)
	user: string
	// Connection hash (%C)
	hash: string
	// ProxyJump configuration (%j)
	jump?: string
	// Broker socket path
	broker?: string
})
#Policy: close({
	// Address to listen on
	listen?: string
	// OIDC issuer URL
	oidc_issuer?: string
	// OIDC audience (client ID)
	oidc_audience?: string
	// CA public key (URL, file path, or literal SSH key)
	ca_pubkey?: string
	// Default certificate expiration (e.g., 5m)
	default_expiration?: string
	users?:              _
	defaults?:           _
	hosts?:              _
})

It's not good docs, but it directly generated from the code, so it is at least accurate, and close to free :-)

I think the CUE website does a pretty bad job of explaining its value, to be honest. It's a darned useful tool even in the small. The website just hides that basic usefulness behind piles of articles of the "look at all the really powerful stuff it can do" for advanced cases.

This blog is now on Astro thanks to Antigravity!

Philipp Hartenfeller Blog RSS Feed — Mon, 08 Dec 2025 02:00:00 GMT

How I migrated my blog from a custom React setup to Astro, improving performance and maintainability.

From Azure Functions to FreeBSD

Julio Merino's corner on Julio Merino (jmmv.dev) — Sun, 07 Dec 2025 22:00:00 GMT

Putting FreeBSD’s “power to serve” motto to the test.

On Thanksgiving morning, I woke up to one of my web services being unavailable. All HTTP requests failed with a “503 Service unavailable” error. I logged into the console, saw a simplistic “Runtime version: Error” message, and was not able to diagnose the problem.

I did not spend a lot of time trying to figure the issue out and I didn’t even want to contact the support black hole. Because… there was something else hidden behind an innocent little yellow warning at the top of the dashboard:

Migrate your app to Flex Consumption as Linux Consumption will reach EOL on September 30 2028 and will no longer be supported.

I had known for a few weeks now, while trying to set up a new app, that all of my Azure Functions apps were on death row. The free plan I was using was going to be decommissioned and the alternatives I tried didn’t seem to support custom handlers written in Rust. I still had three years to deal with this, but hitting a showstopper error pushed me to take action.

All of my web services are now hosted by the FreeBSD server in my garage with just a few tweaks to their codebase. This is their migration story.

Manuel was annoyed

Annoying Technology — Sun, 07 Dec 2025 21:31:00 GMT

Ogres Websites are like onions, they have layers! Thanks for the submission, Private Sender said: Is this what is meant by the Content Mines? We have to dig through layers of cruft to get to what we’re looking for?

Codex CLI vs Chat - Tokens, Output Quality, and Motivation

Scramblings — Sun, 07 Dec 2025 16:30:00 GMT

My experience comparing OpenAI Codex CLI vs a chat+files workflow, associated token usage, output quality comparisons, and a very real dip in motivation.

Obfuscating Image Links

Alexander Gromnitsky's Blog — Sun, 07 Dec 2025 16:19:47 GMT

I noticed this recently, though it started happening about a year ago. On some websites (archive.org's bookreader), a normal <img> tag suddenly began to look like some insane MS Internet Explorer extension from 1998:

<img src="blob:https://example.com/b501e863-fe43-4b63-ae5d-dac14cac097e">

The web page that contains it renders the image fine, but when a fairly naïve user posts that link into a chat, it results in nothing: the blob referenced by <img> exists only in the memory of a specific browser instance, & the server will return 404 for any https://example.com/UUID.

Why do they do this? Every n years some people get scared of hotlinking (bastards keep stealing our traffic), AI luddites try to ruin business of evil corporations, & fans of toy-level DRM amuse themselves with a new scheme.

If you look at the fetch-requests of such a page, you'll see resources that look like images but actually aren't:

$ url='https://ia800206.us.archive.org/🙈.jpg'

$ curl -sI "$url" | grep -e type -e length -e obfuscate
content-type: image/jpeg
content-length: 267470
x-obfuscate: 1|uoEV6/PZOWtGhOZdVM898w==

$ curl -s "$url" | head -c25 | file -
/dev/stdin: data

Such a .jpg is encrypted. Part of the key is in the X-Obfuscate header, but neither a random AI scraper nor any social network knows about this. The cipher is also not disclosed, & every website may use any scheme it wants: following any recommendations would defeat the entire purpose of obfuscation.

The image-rendering algorithm then becomes:

download the encrypted file;
decrypt it using the key from the corresponding header & push the result into a blob;
create a link to the blob using URL.createObjectURL function;
inject into the DOM an img element whose src attribute is equal to the newly created link.

We can increase entropy further by writing our own custom element:

<img-blob alt="a fluffy cat" src="cat.bin"></img-blob>

that will do all of the above on its own. (I terser'ed the source code of the example for I absolutely don't want you to use it in anything serious: the entire approach is extremely user-hostile & anti-web.)

For efficiency, archive.org AES-CTR-encrypts only the first 1024 bytes of the image. Browsers know about AES but strictly require a secure context that can be annoying during testing; hence, for mickey mouse DRM we can simply use XOR-encryption.

The X-Obfuscate header itself can be obfuscated even more, e.g.:

x-obfuscate: rlW2MKWmnJ9hVwbtZFjtVzgyrFV6VPVkZwZ0AFW9Pt==

looks like a base64 string, but:

$ echo rlW2MKWmnJ9hVwbtZFjtVzgyrFV6VPVkZwZ0AFW9Pt== | base64 -d | xxd
base64: invalid input
00000000: ae55 b630 a5a6 9c9f 6157 06ed 6458 ed57  .U.0....aW..dX.W
00000010: 3832 ac55 7a54 f564 6706 7400 55bd 3e    82.UzT.dg.t.U.>

I checked if DeepSeek could figure it out: it spent 9 minutes & left 2 villages in Zhejiang province without water, was several times very close to the target, but ultimately failed.

The string had been post-processed with rot13:

$ alias rot13="tr 'A-Za-z' 'N-ZA-Mn-za-m'"
$ echo rlW2MKWmnJ9hVwbtZFjtVzgyrFV6VPVkZwZ0AFW9Pt== | rot13 | base64 -d
{"version": 1, "key": "12345"}

As homework, you can add an equivalent of loading="lazy" to the custom element using the Intersection Observer API.

Ways in which GenAI has changed my (tech) life so far

Julien's DevRel corner — Sun, 07 Dec 2025 13:35:32 GMT

GenAI changed everything: harder to find quality content, social media flooded with bots, lost communities. But maybe it's making us more human again? #GenAI #TechCommunity

A Parkinson’s disease stem cell therapy

Padirac Innovations' blog — Sun, 07 Dec 2025 11:45:43 GMT

Chinese medical experts have created an ultra-efficient stem cell approach to Parkinson’s disease. The therapy aimed to induce pluripotent stem cells (iPSCs) to become neuron cells that could only...

You Gotta Push If You Wanna Pull

Gunnar Morling — Sun, 07 Dec 2025 11:05:00 GMT

Table of Contents

Materialized Views
Embracing Data Duplication
Streams for machines, tables for humans

Historically, data management systems have been built around the notion of pull queries: users query data which, for instance, is stored in tables in an RDBMS, Parquet files in a data lake, or a full-text index in Elasticsearch. When a user issues a query, the engine will produce the result set at that point in time by churning through the data set and finding all matching records (oftentimes sped up by utilizing indexes).

Putting Claude in Container Jail: My localdev Setup

Greg Herlein — Sun, 07 Dec 2025 10:00:01 GMT

I let Claude Code do whatever it wants without asking permission.

Before you spit out your coffee: I keep it in a jail. A container jail.

Vibe Coding Book Review

Greg Herlein — Sun, 07 Dec 2025 10:00:01 GMT

I don’t like the term “vibe coding.” I strongly prefer “AI-assisted software engineering.” But regardless of what you call it, Gene Kim and Steve Yegge have written a book about it - and their journey from skeptics to true believers is the most interesting part.

Fleeing Deer

Nicola Iarocci — Sun, 07 Dec 2025 08:31:58 GMT

I swear it’s not an impressionist painting, just a blurry photo I took yesterday during my forest walk. The deer were watching me from the edge of the woods, not far away. The moment lasted a long time, until I ruined it by pulling out my phone. At that point, they took flight.

If you’re reading from the RSS feed or the newsletter, click here to see the actual image.

Why speed matters

Nicola Iarocci — Sun, 07 Dec 2025 07:59:56 GMT

If everything is slow-moving around you, it is likely not going to be good. To fully make use of your brain, you need to move as close as possible to the speed of your thought.

– Daniel Lemire, Why Speed Matters.

How To Podcast

swyx's site RSS Feed — Sun, 07 Dec 2025 07:31:41 GMT

Through my 4 (!) podcasts I obviously have built up a lot of opinions on podcasting over the years. Here's some of them. The two outlier podcasts of our time are Dwarkesh and TBPN, and I will explain my mental model of them in a separate post - basically the McClusky Curve applied. the following advice is what I strongly believe for the "average" podcast that wants to do well but not necessarily being full time top tier influencer level. Also, this is primarily for professional/technical interview guest-led podcasts, but I also do have opinions on non-guest-led podcasts as well.

Going direct: notes on Eli Lilly at a trillion

Alex’s blog — Sun, 07 Dec 2025 02:00:00 GMT

Multi-Paxos: Building a Simple Replicated Log in Python

Bytepawn - Marton Trencseni — Sun, 07 Dec 2025 01:00:00 GMT

This post builds a minimal Multi-Paxos system in Python with Flask HTTP endpoints, showing how repeated Paxos rounds form a fault-tolerant replicated log.

Finding Gene Cernan's Missing Moon Camera

trv.rs — Sat, 06 Dec 2025 18:19:00 GMT

When you’re going to the moon, you’re assigned a camera with a 60mm lens that gets strapped to your chest to document samples, experiments, and the lunar terrain. Both astronauts get their own, clearly labeled with a sticker on the side: “CDR” for commander and “LMP” for lunar module pilot, but they weren’t mutually exclusive, often being swapped throughout the mission based on what film they were shooting with.

I love websites dedicated to a single purpose… a lifetime of attention to detail. This is such a treasure hunt. Also the stickers from their store are awesome.

Finding Gene Cernan's Missing Moon Camera — Space Camera Co. - www.spacecamera.co

On the boundaries of humanity

Nicola Iarocci — Sat, 06 Dec 2025 17:54:25 GMT

For most of humankind, and for tens of thousands of years, the idea that humanity includes every individual on the face of the earth has not existed. This designation stops at the border of a tribe or linguistic group, sometimes even at the edge of a village.

— Paraphrased from Claude Lévi-Strauss, Race and History, 1952 (full quote and context)

I guess my beloved Star Trek future—post-scarcity, post-conflict, beyond divisions—is still far away.

Images as Context

Thought Eddies — Sat, 06 Dec 2025 17:00:12 GMT

Images as Context

Discovering the indieweb with calm tech

Built on Shards of Silicon: Robert Alexander's Tech Blog — Sat, 06 Dec 2025 02:00:00 GMT

Blog Quest and StreetPass help you discover the independent web

2025 in Review

Jason Eckert's Website and Blog — Sat, 06 Dec 2025 02:00:00 GMT

Every December I like to step back and reflect on the past year… my own personal retrospective. Just as software teams use sprints to learn and improve, I’ve found that looking back helps me stay aligned with the person I want to become. And looking back, 2025 wasn’t just memorable. It was epic.

My outdoor hiking footprint grew yet again this year. Each month, I explored new sections of the Bruce Trail and surrounding regions, from beautiful frozen lakes, to winding freshwater streams, glacial moraine forests, and even cliff faces dotted with caves. Some routes were moderately difficult while others pushed my limits with steep elevation changes (including one that ended at a mountaintop tea house!). And the fall colours? Absolutely spectacular.

Netflix Strikes $83B Takeover Deal For Warner Bros.

The Techee — Fri, 05 Dec 2025 23:34:50 GMT

Movie streaming giant Netflix (NASDAQ: NFLX) has struck an outsized deal to acquire film and television powerhouse Warner Bros. Discovery (NASDAQ: WBD). Netflix will pay $72bn in cash and stock to acquire Warner Bros. It’ll also assume Warner Bros.’ liabilities, pushing up the deal’s value to $82.7bn. Netflix is the most popular online video streaming […]

The post Netflix Strikes $83B Takeover Deal For Warner Bros. appeared first on The Techee.

Code from my session at WPC 2025

Nicola Iarocci — Fri, 05 Dec 2025 11:07:42 GMT

On Wednesday, I held a session titled “Feature Flags and Dynamic Configurations in C#” at WPC 2025. It went well, at least judging by the offline questions that came in at the end of the session and which almost made us late for lunch.

Attending WPC is always exciting. The audience is large, the rooms are big and well-equipped, the energy is just right, and there’s always a chance to catch up with friends and colleagues. I especially enjoy seeing fellow Microsoft MVPs and speakers.

In at the deep end

I Learnt — Fri, 05 Dec 2025 10:48:00 GMT

In my first “real” job I was definitely thrown in at the deep end on my first day and it changed my career.

Why Go for Robotics?

Greg Herlein — Fri, 05 Dec 2025 10:00:01 GMT

Python dominates robotics today. C++ is the serious choice. But I’m starting to think we’ve been sleeping on Go. Here’s why I’m actively exploring it.

Betting on the Lottery with Bash and /dev/urandom

Heitor's log — Fri, 05 Dec 2025 02:00:00 GMT

Trying to win the lottery with pure Linux RNG magic.

Review: Julia trimming for Advent of Code 2025

viralinstruction — Fri, 05 Dec 2025 02:00:00 GMT

Trying out trimming in Julia for AoC 2025

a14m

cjlm.ca — Fri, 05 Dec 2025 02:00:00 GMT

It strikes me that “a14m” could be a numeronym for anthropomorphism. I’m not sure the world needs any more numeronyms but it is tiresome word to type out. Anthropomorphisation would be a18n which sounds a little too close to i18n.

Nested tags in OpenAPI 3.2

LornaJane — Thu, 04 Dec 2025 22:53:49 GMT

OpenAPI has always had support for simple tags, but the OpenAPI 3.2 release brought in some serious tag upgrades including a summary field, a “kind” field with registry, – and the ability to nest tags which is the focus of … Continue reading →

3 Years of ChatGPT

🦉 olshansky 🦁 — Thu, 04 Dec 2025 20:05:49 GMT

On December 1st, 2022, I published a blog post titled “24 hours of ChatGPT”.

It was one of the first times in my life when I realized how utterly wrong I could be about something.

In 2012, I vividly remember building out a prototype of a standalone Twitter DMs app as an intern the day before my 20th birthday. I read a post about how Google was able to detect cats using machine learning. That moment was exciting, but nothing like what arrived a decade later.

To hide in the woods

Nicola Iarocci — Thu, 04 Dec 2025 16:16:35 GMT

The woods, the jungle, the forest are the boundary between the wild and the civilized, a place of shelter and legendary fears, of hiding and losing oneself. A place of wonder and unease. [..] But what a mythical power lies in this tangle of nature, shadows, and roots, where the unconscious of the world can be found.

– Vinicio Capossela

Exploring the game files of Battlefield Bad Company

utf9k — Thu, 04 Dec 2025 12:30:00 GMT

A good game and a good archeological dig

Salary Negotiation Live on HiredCoach

hlfshell — Thu, 04 Dec 2025 07:30:00 GMT

Right off the bat I had users asking for salary negotiation as a feature on HiredCoach. Apparently I’m not the only one that dreads the process of asking for more money and the tension the conversation can have. It’s live now. I went from idea to prototype in about a day, and only a few more days for the feature to be 99% there. I definitely can think of a few things I’d like to improve on it but I want it in the hands of users first.

Updated SafeStop

hlfshell — Thu, 04 Dec 2025 07:27:51 GMT

About five years ago (ok, that hurt to type. The days are long but the years are short…) I wrote SafeStop. I had made it to coordinate proper shutdown protocols across multiple services running in a large monolith application. I decided to renew it, modernize it, and added some dependency features (so service B can shutdown after service A is shutdown, etc). Another product of my recent golang kick.

The Soul of Claude

Zappable — Thu, 04 Dec 2025 04:59:49 GMT

In a post on LessWrong, the author discussed how he was able to chat with Claude and piece together an approximate “soul document” that guides Claude’s values.

How I would Engineer Machine Learning - Redux

Shank Space — Thu, 04 Dec 2025 03:31:57 GMT

If you were to start preparing for ML roles today, what would your step by step approach look like, the concepts you would focus on and what strategies would you use to learn better.

I would do the following, roughly a couple of these together at a time

★ Practice leetcode questions, know the patterns of problems
★ Practice the basics of ML. A good benchmark is you should know everything that Josh Starmer’s StatQuest talks about, I think he has a couple of playlists.
- But know the basics thouroughly. For example, pick one algorithm from each class of problems and know EVERYTHING about it. Linear Regression, Logistic Regression, Decision Tree, SVM, K Means Clustering. Deep enough to answer meta questions like:
  - Why sigmoid and not any other function in Logistic regression
  - Why use log in logistic regression
  - How can you predict continuous values in DT
- Apart from models also know ML basics - things like Bias, Variance, Overfitting, Regularization, Why layers in NN, How overfitting manifests in DT NN and LR, Accuracy Precision Recall F1 scores, RoC curves, How to identify good model, how to identify good data, Feature Engineering, Pruning and when to stop training
★ Learn basic probability and stats thoroughly. Anything in a Probability 101 course is fair game. You should be intuitively familiar with things like Distributions (Normal, Binomial, Poission, Bernoulli), Expectations, Variance, Conditional Probability, Independent Events, Hypothesis Testing, Graphs, Mean-Median-Mode and when to use what, Arithmetic and Geometric means
Try going deeper into fancy things like Transformers, LLMs, etc. Once you know the foundation it will be very easy to understand what is happening elsewhere.
★ If you are able to pick any topic and hold a lesson on it, and go as deep as 5-whys into anything above without stumbling, you are awesome now
★ Know everything about any ML project in your resume. You should be able to explain it at various levels of abstraction - from a new software engineer to a seasoned professional in that exact field.
★ Look up ML System Design problems. Break it down and build the entire system, for example, if you had to build the search bar for Amazon in its website how would you fill the suggestions below? Remember the constraints (millions of products, different semantics - apple could mean the fruit or company, super fast predictions - where to store the mode)

There are a lot of resources online. I wouldn’t stress too much on the “best” way to learn as long as you are hitting the above points. Focus more on the basics. Some suggestions (again, not the best, but a good place to start and refer):

★ Blind 75 of Leetcode
★ Josh Starmer Stat Quest Machine Learning
★ Machine Learning System Design by Chip Huyen
ML Roadmap
An Introduction to Statistical Learning
ML at Stanford, a good breadth of topics
When you have MORE time and want to go DEEPER:

All the best :)

★ marks essentials fast ramp-up for ML interviews

Generating Fantasy book titles the old way

Bruno Croci — Thu, 04 Dec 2025 02:00:00 GMT

Back in 2012, I was really into fantasy and historical fiction books: The Name of the Wind (Patrick Rothfuss), A Magic of Twilight (S. L. Farrell), Armageddon (Eduardo Spohr), The Warlord Chronicles and The Saxon Stories (Bernard Cornwell), etc. I was also listening to a lot of podcasts on the subject, and following most of the latest releases in these genres in Brazil. I eventually noticed a pattern in the book titles.

I think it’s much more obvious in the translated Portuguese titles than it is in English, but I’ll explain it with the English titles, because I can find enough examples that follow the rule. Most of the books are titled something like:

[Article] Noun _of_ [Article] Noun

Examples:

The Name of the Wind
A Magic of Twilight
Enemy of God
Lords of the North
A Game of Thrones
The Fellowship of the Ring
The Wheel of Time

In English, you’ll sometimes find a slightly different structure, with an adjective coming before the noun, like The Pale Horseman. In Portuguese, since the adjective always comes after the noun, I think it’s much more common to use adjective phrases instead of just a single adjective. Plus, in English there are two ways of forming adjective phrases: Noun Noun and Noun of Noun, and they often mean different things. In Portuguese, this difference is not as clear.

Based on that, I created a “fantasy book title generator”, and it’s been online for about 13 years now, at the same address: https://labs.crocidb.com/fantasy-generator/. Somehow it’s still popular.

Fantasy Generator

Even in the age of LLMs, it still gets around 100 visits per month. I’ve had people tell me they’ve used it for their DnD campaigns, including people who didn’t even know I was the one who made it in the first place.

The implementation is really basic. All I have is a list of nouns for the subject and another one for the adjective phrase:

["O", "Anjo"],
["Os", "Anjos"],
["O", "Rei"],
["Os", "Reis"],
["O", "Deus"],
["Os", "Deuses"],
["O", "Panteão"],
["A", "Irmandade"],
...

Articles are separated because sometimes they can be omitted, which multiplies the possibilities even further.

For the adjectives, Portuguese helped me even more, because we always combine the preposition and the article that comes after it. For example, in “Lords of the North”, the “of the” would be “de o Norte”, but “de o” becomes “do”, so it’s shorter and easier:

["do", "Trono"],
["do", "Reino"],
["da", "Coroa"],
["do", "Castelo"],
["da", "Guerra"],
["da", "Paz"],
["da", "Coragem"],
["da", "Justiça"]

I kept them separated because at some point I was going to introduce indefinite articles to the mix, but I just never did.

Those nouns and adjectives are divided into different categories, things like “Angels”, “Kings”, “Gods”, “Vampires”, “Magic”, etc., from which the user can pick their own combination. The code to generate a title is really simple, and the last change was 13 years ago:

function generate()
{
	var nouns = [];
	for (var i in noun)
	{
		var element = $("#" + i);
		if (element.length == 0 || element.attr("checked"))
		{
			nouns = nouns.concat(noun[i]);
		}
	}
	
	var index = Math.floor(Math.random() * nouns.length);
	var selectedNoun = nouns[index];
	var article = Math.floor(Math.random() * 3) == 1;
	
	var generatedName = "";
	if (!article) generatedName += selectedNoun[0] + " ";
	generatedName += selectedNoun[1];
	
	var adjs = [];
	for (var i in adj)
	{
		var element = $("#" + i);
		if (element.length == 0 || element.attr("checked"))
		{
			adjs = adjs.concat(adj[i]);
		}
	}
	
	index = Math.floor(Math.random() * adjs.length);
	var selectedAdj = adjs[index];
	
	generatedName += " " + selectedAdj[0] + " ";
	generatedName += selectedAdj[1];
	
	$("h1").text(generatedName);
};

An LLM nowadays can give you results that are so much better, more diverse and more complex than that, but I find some beauty in simple solutions like that. Before I tried implementing a zodiac horoscope generator too. It was a bit more complex, because I had to divide phrases in different parts to have full sentences that made sense, but it worked beautifully too.

PatriotCTF 2024 Blob Writeup

Justus Perlwitz — Thu, 04 Dec 2025 02:00:00 GMT

This article contains my writeup for the PatriotCTF 2024 Blob challenge.

Paxos: Lamport's Crown Jewel for Replicated State Machines

Bytepawn - Marton Trencseni — Thu, 04 Dec 2025 01:00:00 GMT

A straightforward explanation of Paxos using a simple Python Flask HTTP implementation to show how distributed systems achieve consensus in the presence of faults.

Fizzy is as good as it gets

João Alves — Wed, 03 Dec 2025 19:19:24 GMT

I’ve been thinking more about the Fizzy launch and the reaction around it. To me, the most interesting part is not the Kanban app itself, but the model behind it.

A lot of the discussion online jumped straight to the label. “It’s not real open source”. Sure, if your first instinct is to evaluate everything by strict licensing categories, Fizzy will not tick every box. But focusing solely on the label misses the model’s practical value and its intended use.

In practice, this looks like a pretty reasonable deal. You get full access to the code. You can run it forever, on your own hardware, with no limits. You can fix bugs, propose changes, learn from the implementation, and fork it if you must. And yes, you cannot turn around and sell the same hosted product. That seems… fine? Most companies do not want to run a Fizzy clone. They want a workflow tool that works and a codebase they can understand.

There is also something refreshing about how transparent this is. Many companies — Elastic, Redis, etc. — in the past tried to play both sides. They branded themselves as open source, then quietly added “restrictions” later. Or they built a community, waited for adoption, and then tightened the license once there was leverage. Fizzy is the opposite. 37Signals set the rules up front. No bait and switch. No ecosystem lock-in. No “surprise, we changed the license”. You know precisely what you are getting on day one.

If we zoom out, this model has upside for the whole ecosystem. It encourages companies to share real production code again. Not toy apps. Actual software that real teams can study and learn from. The industry lost a lot of that when everything moved behind SaaS walls.

Fizzy brings back the “view source” mindset for the backend. And that is valuable. Not because you want to copy it, but because reading good code makes you a better engineer.

To me, that’s the bigger story here. This is less about a Kanban tool and more about how 37Signals approaches licensing and incentives. They keep a clear commercial path. Users get transparency, portability, and a meaningful opportunity to learn from real production code.

If this becomes a trend, we all win.

— João

AI and Drinking The Tech Kool-Aid

Synystron Synlogica — Wed, 03 Dec 2025 15:23:56 GMT

One of the reasons I haven’t “drunk the Kool-Aid” on AI is because this is not my first rodeo, kids.

Apple will not let me join the Developer Program — and will not say why

Igor Kulman — Wed, 03 Dec 2025 06:29:12 GMT

I’ve been building apps for a long time. More than a decade ago I shipped several apps on the Windows Phone Store — and back then, publishing as an indie was empowering. Even though dealing with Microsoft was often frustrating, at least I could publish my apps under my own name. Ever since switching fully to iOS professionally, I’ve been waiting for a good personal project idea. Something small but meaningful.

November 2025 Reading List

Den Delimarsky — Wed, 03 Dec 2025 02:00:00 GMT

A summary of all the books I’ve managed to read in November of 2025.

Bun is joining Anthropic

Kevin B. Ridgway's Blog — Tue, 02 Dec 2025 23:58:34 GMT

I'll be honest. Bun joining Anthropic wasn't on my bingo card.

Congrats to the team!

On Writing, Speaking and Thinking

Thought Eddies — Tue, 02 Dec 2025 23:35:45 GMT

On Writing, Speaking and Thinking

Higher Education and AI: Some Musings

Ecce Homology on Bastian Grossenbacher Rieck's personal homepage — Tue, 02 Dec 2025 22:00:00 GMT

To the surprise of exactly no one, AI tools are also rapidly changing the landscape of higher education. Whether for good or for worse is something that I am debating with myself every day—I vacillate between “Butlerian Jihad Now!” and a non-ironic “O brave new world, that has such algorithms in ’t.”

Starting with the good parts, I see students working on their own projects, pursuing some creative endeavors, and basically having a blast with creating things. I also see some of them becoming sleuths, trying to figure out how to lead a certain large language model astray, and taking an almost perverse pleasure in watching a model go “off-script.” I also see students translate slides and other lecture materials, get additional explanations, and work through some examples. All of that is great and exciting. The catch, however, is that, anecdotally speaking, this is what the strongest students do. They know how to wield these tools or at least show some restraint.

The bad parts are tales—told by students themselves—of getting tricked by AI, or, accounting for free will on the side of the student and a (purported) general lack of consciousness on the side of a large language model, tricking themselves into believing falsehoods. Not falsehoods in the sense of “The Earth Is Flat!!!1!” but smaller falsehood that sting more like “I understand this topic” or “I know this programming language.” I am reminded of Feynman’s famous quote:

The first principle is that you must not fool yourself — and you are the easiest person to fool.

It is clear that, to some extent, we are fooling ourselves. We are fooling ourselves by performing cognitive offloading at unprecedented scales. We are fooling ourselves by accepting shallow summaries instead of the nuanced whole. And we are following ourselves by believing that we have to do it because everyone does it.

Like any technology worth its salt, AI offers a lot but does not come with a manual. It is up to us to rewrite the “rules of engagement” or create entirely new guardrails. We owe it to the students!

I remain optimistic about the gainful use of AI in higher education but it will take some substantial changes of our teaching practices. We cannot afford to ignore the writing on the wall for much longer.

BlackBerry

🦉 olshansky 🦁 — Tue, 02 Dec 2025 19:04:21 GMT

Though I’m sure this movie was over-dramatized in places, it was entertaining, nostalgic, and educational all at once.

I absolutely loved it and would recommend it to any of my friends.

The stretch from 2000 to 2007 really pulled me back. Watching it now, with a professional lens, helped me finally process what was happening back then, even though I was just a kid watching the world shift.

The innovator’s dilemma Mike Lazaridis faced was painfully real. If I ever get the chance, I’d love to know what was actually going through his mind during the iPhone reveal.

Eve 2.2.4

Nicola Iarocci — Tue, 02 Dec 2025 17:06:46 GMT

Eve v2.2.4 was just released on PyPI. It is a minor update, with a validation fix contributed by smeng9. See the changelog for details.

When software becomes fast food

João Alves — Tue, 02 Dec 2025 16:47:39 GMT

Generative artificial intelligence has amazed the World. Since OpenAI launched ChatGPT 3, its user adoption has been staggering. In 2022, ChatGPT surpassed one million users in just five days. For comparison, Instagram needed 2.5 months back in 2010.

And it’s not just OpenAI. Anthropic has Claude, one of the best models for programming tasks. Google is pushing forward with Gemini and VEO, leaders in video. In China, Alibaba Cloud is moving fast with its open-source model Qwen. And rumor has it that Meta is offering millions — with stock packages worth billions — to attract top AI researchers. It’s wild.

Programmers lived through a golden age. The zero-interest-rate period (ZIRP), the post-pandemic SaaS boom, and a flood of venture capital pushed salaries up, brought quick promotions, and created a culture where “don’t upset the developers” became an operating principle. But the world has changed. Inflation forced central banks to raise interest rates. Companies realized they had over-hired. Profitability became the focus. Layoffs followed.

As an industry, we also realized something important: writing software is far more statistical than we wanted to believe. With the correct training data and good examples, AI can generate high-quality code. And we learned something deeper: the first jobs being disrupted are white-collar jobs. That fundamentally shifts the landscape.

AI and restaurants

Now that code is cheap to produce, the bottlenecks have moved elsewhere:

Can we deploy at the speed we generate?
Can we maintain quality?
Can we design systems well when implementation stops being the hard part?
Who reviews everything we now generate at absurd speed?

More software means more people “programming” with less expertise. Here’s my thesis: The average developer’s value decreases. The value of true experts goes up.

AI flattens the entry barrier: anyone can produce decent code. But when everyone produces more, complexity and errors grow exponentially. Suddenly, judgment matters more than ever. It’s like restaurants. There’s fast food: cheap, immediate, and “good enough”. And there’s haute cuisine: slow, refined, and hard to replicate. Both feed you, but they’re not the same, and they don’t cost the same.

Following Simon Wardley’s terminology, coding is moving from the custom-built/product phase into the commodity/utility phase. Once something crosses that boundary, the competitive advantage is no longer in producing it — because it’s cheap — but in the components and decisions around it: architecture, experience, integration, product vision, operations, governance.

What can be industrialized will be automated. What requires taste and expertise becomes more valuable.

The power-law analogy: restaurants, software, and the shape of value

Beyond metaphors of speed and quality, the restaurant world also offers a structural mirror for where software is heading. Like in tech, value in restaurants follows a power-law curve. A tiny number of world-class kitchens and chefs — Noma, Jiro, Eleven Madison Park — capture a disproportionate share of prestige, profit, and attention. Meanwhile, a long tail of standardized eateries produces for the masses, with little margin or differentiation. Software is entering the same curve.

AI has made code production cheap and plentiful. It’s the equivalent of mass-produced meals. But in this abundance, value flows upward, concentrating in those who bring coherence, creativity, and judgment. The ones who design the menu, not just cook from it. In tech: senior engineers, staff engineers, architects.

A few become dramatically more valuable. Most operate in a dense long tail, increasingly indistinguishable. The shape is no longer a bell curve. It’s a power law.

Psst! If you're enjoying this article, consider subscribing to the newsletter and buying me a coffee.

You can now serve thousands with AI-generated code. But only a handful will know how to combine it, shape it, and turn it into something meaningful, scalable, and enduring. Quantity is no longer scarce. Taste is.

As a developer, what do you do?

I see three paths:

AI operator. Be fast at generating, iterating, and validating. You don’t need deep expertise, but you do need adaptability and systems thinking.
True expert. Go deep. Architecture, performance, security, system design, databases, UX, product. When things break, expertise is what matters.
Decider. Move toward product, business, and strategy. If coding is cheap, deciding what to build becomes the real source of value.

What won’t work:

Pretending nothing changed.
Competing with AI on speed.
Staying in the shallow layer, AI can already replicate.

What will work:

Using AI as a multiplier.
Increasing your technical judgment.
Understanding systems and tradeoffs.
Becoming great at ambiguity, product, and business context.

If you're enjoying this article, consider subscribing to the newsletter and buying me a coffee.

As a manager, what do you do?

Managers face a similar shift. If AI makes output cheap and teams smaller, the role is no longer task coordination. The role becomes managing complexity. Three directions stand out:

The strategist. AI accelerates “what we can build”, but not “what we should build”. Strategy becomes central.
The sociotechnical architect. Code is cheap; integration is complex. You design the system of teams, AI, processes, and culture.
The curator of expertise. When everyone produces more code thanks to AI, the scarce skill is judgment. The manager becomes a multiplier of taste, quality, and systemic thinking.

Final thoughts

AI is industrializing software in the same way industrialization changed cooking. We will see a lot more “fast-food software”: cheap, fast, and good enough. That’s fine. But when production becomes easy, judgment becomes the real bottleneck.

Like elite football, the industry is shifting toward a power-law World: a small group of highly skilled engineers will capture disproportionate value, while the rest compete in a long tail of abundant supply.

AI is not removing people. It is shifting the value.

The question is not whether AI will replace you. The question is what role you want to play in this new league.

— João

PS: I’m building RotaHog, a lightweight tool for managing team rotation schedules (on-call, support shifts, release duties, etc.). Try it if you’re tired of hacking spreadsheets or Slack threads together. I’d love your feedback!

If you enjoyed this article, consider subscribing to the newsletter and buying me a coffee.

Note: This article is a translation, with some changes, from my original "Cuando el software se vuelve fast food", in Spanish.

QEMU-based instruction execution counting

Muxup — Tue, 02 Dec 2025 14:00:00 GMT

Although analysing performance by way of instruction counting has obvious limitations, it can be helpful (especially when combined with appropriate analysis scripts) to get rapid feedback on the impact of code generation changes or to explore hypotheses about why code from one compiler might be performing differently from another - for instance, by looking at instruction mix in the most executed translation blocks. In this post we'll look at how to capture the necessary data to perform such an analysis using a QEMU plugin. Future posts will give details of the analysis scripts I've used, and walk through an example or two of putting them to use.

Modifying QEMU

Over the past few years, QEMU's plugin API has developed a fair bit. QEMU includes several plugins, and hotblocks provides almost what we want but doesn't allow configurability of the number of blocks it will print information on. I submitted a small patch series (and submitted it a second time addressing this and other minor issues found along the way. The series has now been accepted by the maintainer.

To build QEMU with this patch:

git clone https://github.com/qemu/qemu && cd qemu
git checkout v10.1.2
cat - <<'EOF' > hotblocks.patch
index 98404b6885..8ecf033997 100644
--- a/contrib/plugins/hotblocks.c
+++ b/contrib/plugins/hotblocks.c
@@ -73,28 +73,29 @@ static void exec_count_free(gpointer key, gpointer value, gpointer user_data)
 static void plugin_exit(qemu_plugin_id_t id, void *p)
 {
     g_autoptr(GString) report = g_string_new("collected ");
-    GList *counts, *it;
+    GList *counts, *sorted_counts, *it;
     int i;

     g_string_append_printf(report, "%d entries in the hash table\n",
                            g_hash_table_size(hotblocks));
     counts = g_hash_table_get_values(hotblocks);
-    it = g_list_sort_with_data(counts, cmp_exec_count, NULL);
+    sorted_counts = g_list_sort_with_data(counts, cmp_exec_count, NULL);

-    if (it) {
+    if (sorted_counts) {
         g_string_append_printf(report, "pc, tcount, icount, ecount\n");

-        for (i = 0; i < limit && it->next; i++, it = it->next) {
+        for (i = 0, it = sorted_counts; (limit == 0 || i < limit) && it;
+             i++, it = it->next) {
             ExecCount *rec = (ExecCount *) it->data;
             g_string_append_printf(
-                report, "0x%016"PRIx64", %d, %ld, %"PRId64"\n",
+                report, "0x%016"PRIx64", %d, %ld, %"PRIu64"\n",
                 rec->start_addr, rec->trans_count,
                 rec->insns,
                 qemu_plugin_u64_sum(
                     qemu_plugin_scoreboard_u64(rec->exec_count)));
         }

-        g_list_free(it);
+        g_list_free(sorted_counts);
     }

     qemu_plugin_outs(report->str);
@@ -170,6 +171,13 @@ int qemu_plugin_install(qemu_plugin_id_t id, const qemu_info_t *info,
                 fprintf(stderr, "boolean argument parsing failed: %s\n", opt);
                 return -1;
             }
+        } else if (g_strcmp0(tokens[0], "limit") == 0) {
+            char *endptr = NULL;
+            limit = g_ascii_strtoull(tokens[1], &endptr, 10);
+            if (endptr == tokens[1] || *endptr != '\0') {
+                fprintf(stderr, "unsigned integer parsing failed: %s\n", opt);
+                return -1;
+            }
         } else {
             fprintf(stderr, "option parsing failed: %s\n", opt);
             return -1;
diff --git a/docs/about/emulation.rst b/docs/about/emulation.rst
index 4a7d1f4178..e8793b0f9c 100644
--- a/docs/about/emulation.rst
+++ b/docs/about/emulation.rst
@@ -463,6 +463,18 @@ Example::
   0x000000004002b0, 1, 4, 66087
   ...

+Behaviour can be tweaked with the following arguments:
+
+.. list-table:: Hot Blocks plugin arguments
+  :widths: 20 80
+  :header-rows: 1
+
+  * - Option
+    - Description
+  * - inline=true|false
+    - Use faster inline addition of a single counter.
+  * - limit=N
+    - The number of blocks to be printed. (Default: N = 20, use 0 for no limit).

 Hot Pages
 .........
EOF
patch -p1 < hotblocks.patch
./configure --prefix=$(pwd)/inst --target-list="riscv32-linux-user riscv64-linux-user"
make -j$(nproc)
cd ..

Using this plugin to capture statistics from running a binary under qemu-user

Assuming you have an appropriate sysroot, you can run a binary and have the execution information emitted to stderr by doing something like:

QEMUDIR=$HOME/qemu/build
SYSROOT=$HOME/rvsysroot
$QEMUDIR/qemu-riscv64 \
  -L $SYSROOT \
  -plugin $QEMUDIR/contrib/plugins/libhotblocks.so,limit=0,inline=on \
  -d plugin,nochain \
  my_rv64_binary

This produces output like:

collected 2229 entries in the hash table
pc, tcount, icount, ecount
0x00007fffee7012ba, 1, 1, 3737
0x00007fffee7012be, 1, 3, 3737
0x00007ffff741e738, 1, 23, 1074
0x00007fffee71bb38, 1, 5, 884
0x00007ffff741bb2e, 1, 11, 662
...

This listing indicates the address of the translation block, the number of times it's been translated, the number of instructions it contains, and the number of times it was executed. Note that a translation block is not the same as a basic block in the compiler. A translation block can span multiple basic blocks in the case of fallthrough, and this can also mean an instruction may show up in multiple translation blocks.

At least for my use cases, I need something a bit more involved than this. In order to add collection of these statistics to an existing benchmark harness I need a wrapper script that transparently collects these statistics to a file. It's also helpful to capture the runtime address of executable mappings for loaded libraries, allowing translation blocks to be attributed easily to either the binary itself or libc, libm etc. We have gdb connect to QEMU's gdbserver in order to dump those mappings. Do ensure you're using a recent version of QEMU (the version suggested in the patch application instructions is definitely good) for this as I wasted quite some time running into a bug with file descriptor numbers that caused odd breakage.

This qemu-forwarder.sh script will capture the plugin's output in a .qemu_out file and the mappings in a .map file, both of which can be later consumed by a detailed analysis script.

#!/bin/sh
QEMUDIR=$HOME/qemu/build
SYSROOT=$HOME/rvsysroot
QEMU="$QEMUDIR/qemu-riscv64 \
  -L $SYSROOT \
  -plugin $QEMUDIR/contrib/plugins/libhotblocks.so,limit=0,inline=on \
  -d plugin,nochain"

SUFFIX=""
if [ -e "$1.qemu_out" ]; then
  NUM=1
  while [ -e "$1.qemu_out.$NUM" ]; do
    NUM=$((NUM + 1))
  done
  SUFFIX=".$NUM"
fi

GDB_SOCK=$(mktemp -u)
setarch $(uname -m) -R $QEMU -g $GDB_SOCK -D $1.qemu_out$SUFFIX "$@" &
QEMU_PID=$!

RETRY_COUNT=0
while ! [ -e "$GDB_SOCK" ]; do
  RETRY_COUNT=$((RETRY_COUNT + 1))
  if [ $RETRY_COUNT -eq 10 ]; then
    echo "Timed out waiting for gdb socket to be created"
    exit 1
  fi
  sleep 0.1
  if ! kill -0 $QEMU_PID 2>/dev/null; then
    echo "QEMU process died before gdb socket was created"
    wait $QEMU_PID
    exit $?
  fi
done

gdb -batch \
  -ex "set pagination off" \
  -ex "target remote $GDB_SOCK" \
  -ex "break main" \
  -ex "continue" \
  -ex "set logging file $1.map$SUFFIX" \
  -ex "set logging enabled on" \
  -ex "info proc mappings" \
  -ex "detach" > /dev/null 2>&1
wait $QEMU_PID

The above will work under LLVM's lit, though you will need to use a recent enough version that doesn't strip HOME from the environment (or else edit the script accordingly). It also produces output in sequentially numbered files, again motivated by the desire to run under this script from lit as used by llvm-test-suite's SPEC configuration which can involve multiple invocations of the same binary for a given benchmark (e.g. 500.perlbench_r).

Analysing the output

A follow-up post will introduce the scripting I've built around this.

Recording and analysing results from running SPEC

Assuming you have qemu-forwarder.sh, in your llvm-test-suite directory:

CONF=clang-head-test
CLANG_BIN_DIR=$HOME/llvm-project/build/release/bin
CFLAGS="-march=rv64gc_zba_zbb_zbs"
cat - <<EOF > $CONF.cmake
set(CMAKE_SYSTEM_NAME Linux)

set(CMAKE_SYSROOT $HOME/rvsysroot)

set(CMAKE_C_COMPILER $CLANG_BIN_DIR/clang)
set(CMAKE_CXX_COMPILER $CLANG_BIN_DIR/clang++)

set(CMAKE_C_COMPILER_TARGET riscv64-linux-gnu)
set(CMAKE_CXX_COMPILER_TARGET riscv64-linux-gnu)
set(CMAKE_C_FLAGS_INIT "$CFLAGS")
set(CMAKE_CXX_FLAGS_INIT "$CFLAGS")

set(CMAKE_LINKER_TYPE LLD)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
EOF
cmake -G Ninja \
  -B build.$CONF \
  --toolchain=$CONF.cmake \
  -DTEST_SUITE_SPEC2017_ROOT=~/cpu2017 \
  -DTEST_SUITE_SUBDIRS=External/SPEC \
  -DTEST_SUITE_COLLECT_CODE_SIZE=OFF \
  -DTEST_SUITE_COLLECT_COMPILE_TIME=OFF \
  -DTEST_SUITE_USER_MODE_EMULATION=ON \
  -DTEST_SUITE_RUN_UNDER=$(pwd)/qemu-forwarder.sh
cmake --build build.$CONF
$CLANG_BIN_DIR/llvm-lit -v --filter-out='.+_s|specrand' build.$CONF

The 526.blender_r test takes twice as long as the others, so you may wish to skip it by instead executing something like:

$CLANG_BIN_DIR/llvm-lit -v --filter-out='.+_s|specrand|blender' build.$CONF

If you want to re-run tests you must delete the previous .qemu_out and .map files, which can be done with:

[ -n "build.$CONF" ] && find "build.$CONF" -type f -name "*.qemu_out*" -exec sh -c '
    for q_file do
        base_path="${q_file%.qemu_out*}"
        rm -f "$q_file" "${base_path}.map"*
    done
' sh {} +

In order to compare two SPEC builds, you can use something like the following hacky script. Using the captured translation block execution data to generate a plain executed instruction count is overkill as the example tests/tcg/plugin/insn.c can easily dump for this for you directly. But by collecting the data upfront, you can easily dive right into a more detailed analysis when you see a surprising difference in executed instruction counts without rerunning the binary.

#!/usr/bin/env python3

from pathlib import Path
from collections import defaultdict
import sys

def collect_totals(root_dir):
    totals = defaultdict(int)
    root_path = Path(root_dir)/"External"

    for file_path in root_path.rglob("*.qemu_out*"):
        benchmark_name = file_path.parts[4]

        try:
            with file_path.open("r") as f:
                file_total = 0
                for line in f:
                    parts = line.strip().split(',')
                    # Only sum lines that match the expected format.
                    if len(parts) == 4 and parts[2].strip().isdigit():
                        # icount * ecount.
                        file_total += int(parts[2]) * int(parts[3])
                totals[benchmark_name] += file_total
        except Exception as e:
            print(f"Error reading {file_path}: {e}")

    return totals

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: spec-compare-helper <dir_a> <dir_b>")
        sys.exit(1)

    dir_a, dir_b = sys.argv[1], sys.argv[2]
    totals_a = collect_totals(dir_a)
    totals_b = collect_totals(dir_b)

    benchmarks = sorted(set(totals_a.keys()) | set(totals_b.keys()))

    print(f"{'Benchmark':<20} {'DirA':>15} {'DirB':>15} {'Diff (%)':>10}")
    print("=" * 60)

    for benchmark in benchmarks:
        val_a = totals_a.get(benchmark, 0)
        val_b = totals_b.get(benchmark, 0)
        diff_pct = ((val_b - val_a) / val_a * 100) if val_a else float("inf")

        print(f"{benchmark:<20} {val_a:>15} {val_b:>15} {diff_pct:>9.2f}%")

Which produces output looking something like this:

Benchmark                       DirA            DirB   Diff (%)
============================================================
500.perlbench_r         180245097594    182078714777      1.02%
502.gcc_r               220874510659    219647717585     -0.56%
505.mcf_r               131589945456    134271153130      2.04%
508.namd_r              220648061019    216682202888     -1.80%
510.parest_r            291341820355    291844973715      0.17%
511.povray_r             31911866906     31103201809     -2.53%
519.lbm_r                94166321698     86910581403     -7.71%
520.omnetpp_r           138002605692    137676301622     -0.24%
523.xalancbmk_r         283566182007    284735075518      0.41%
525.x264_r              380165035845    379862173371     -0.08%
526.blender_r           660528270138    659361380750     -0.18%
531.deepsjeng_r         355058534962    349621355155     -1.53%
538.imagick_r           238573643488    238560676372     -0.01%
541.leela_r             421886351310    405423320484     -3.90%
544.nab_r               415595728542    391443973852     -5.81%
557.xz_r                132548718317    130229753780     -1.75%

It's worth highlighting that as we're running this under user-mode emulation, the dynamic instruction count naturally never counts any instructions on the kernel side that you would see if profiling a real system.

Article changelog

2025-12-15: Note that the qemu patches have now been accepted in the maintainer's tree.
2025-12-02: Initial publication date.

Gitforest

Brian Sunter — Tue, 02 Dec 2025 12:38:15 GMT

A terminal UI for managing dozens of Git repositories at once: status dashboard, batch git operations, GitHub integration, and background fetches.

How Brian Eno created Music for Airports

Nicola Iarocci — Tue, 02 Dec 2025 12:35:21 GMT

Brian Eno’s Ambient 1: Music for Airports is a landmark album in ambient and electronic music. Although it wasn’t the first ambient album, it was the first album to be explicitly labelled as ‘ambient music’. [..] In this article, I’ll discuss how Music for Airports was created, and I’ll deconstruct and recreate the tracks 2/1 and 1/2. Hopefully, the article will demystify some of Brian Eno’s techniques, and give you some ideas about how to adopt some of his ambient music techniques yourself.

On the usefulness of writing

Nicola Iarocci — Tue, 02 Dec 2025 10:55:03 GMT

I think of it [the usefulness of writing] like breathing but for ideas. We do so much reading all day—there should be a natural balance with producing words too. Inhale, exhale, inhale, exhale…

Joe Boudreau in On 10 Years of Writing a Blog Nobody Reads, an article I agree 100% with.

Tool maintenance and the Lifestyle Licence

Cyber Warhead — Tue, 02 Dec 2025 07:04:23 GMT

Seedling development happens entirely indoors now, under lamps. In the shortest days of the year I set up folding tables in the back room, fill trays with damp promix, and press tomato seeds no deeper than the edge of a... Read More ›

So you want to move from backend code to robotics systems

jodavaho.io — Tue, 02 Dec 2025 02:00:00 GMT

I got a really good question sent to me, and I’d like to archive the response here…

I mostly use Go (previously Java) and am exploring Rust for unmanned systems, particularly embedded work and autonomy like navigation and perception. Given your domain expertise, I’d love to hear your perspective:

I’m bullish on Rust long term. If you’re coming from Go/Java, then you’ve already got the “backend” covered, and a lot of robotics happens in “backend”-like code. So, rust here is more of a curiosity / lateral move for you. Great to try, not required. You could start right now by developing implementations of robotics-like things and making a backend.

Very little “solving” happens on small machines, it happens on on-system servers running in docker, usually. The small computers do little things, usually. So, you can definitely get started with pathfinding, optimization, mapping, image processing in Rust right now, and build small automous systems that mostly live in something you’d call a “backend”. Then plug a webcam in, and hit your “backend” with imagery and you’re off to the races.

If you’re more interested in “robotics systems”, then there’s really no substitute for learning ROS. While ROS is a bit dated, and most serious shops built their own version, ROS2.0 has a bunch of normal practices in it, and every custom robotics framework is defacto compared to ROS2.0 nowadays. This implies C++ and CMake, it’s really hard to get around that. Though there are Rust wrappers and ROS2.0 Rust compliant messaging libraries.

If you’re more interested in “on the metal” code, then ROS2.0 is still relevant, but we’re more into the firmware level things. C is the king here (still). Firmware generally does very little more than manage custom hardware like motors, low level sensors, etc. It often doesn’t do the “thinking”.

So if you’re looking to get into robotics, C and C++ are still the industry breadwinner.

Rust is a great language for this domain, but the libraries and industry adoption is lagging a little. There’s just no serious reason to rewrite your entire stack in Rust at this time, when robotics products are not very mature yet. I definitely have seen production Rust code that flies in warzones, so it does exist, but it’s commonly an outlier.

One huge benefit of Rust that is often overlooked is the immediate compatability of types, build systems, and dependency management across the firmware, system, and backend. This is what will eventually cause Rust to catch up to C++, but it may never replace it and doesn’t need to.

At one with your code

xenodium.com @alvaro — Tue, 02 Dec 2025 02:00:00 GMT

While in the mood to goof around with Emacs, CLI, and image rendering, I've revised an idea to generate some sort of art from your codebase (or any text really). That is, given an image, generate a textual representation, potentially using source code as input.

With that, here's one: a utility to transform images into character art using text from your codebase.

Rather than tell you more about it, best to see it in action.

Just a bit of fun. That's all there is to it.

While I've only run it on macOS, one's written in Go, so should be fairly portable. I'd love to know if you get it running on Linux. The code's on GitHub.

If you're on macOS, I've added a Homebrew on GitHub, so you should just be able to install with:

brew install --HEAD xenodium/one/one

Make it all sustainable

Having fun with one? Enjoying this blog or my projects? I am an 👉 indie dev 👈. Help make it sustainable by ✨sponsoring✨

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

Notes on AI

Obvious Bicycle — Tue, 02 Dec 2025 01:12:40 GMT

A snapshot in time

Comparing the homepage-claims of popular Git hosting providers

zufallsheld — Tue, 02 Dec 2025 01:00:00 GMT

Yesterday I talked to someone about different git hosting solutions and they complained about the marketing bullshit on one of the homepages of a popular provider (guess who!).

I then looked at one provider I liked using and sure enough, most of them use marketing bullshit, rather then selling what …

Insufficient Data for a Meaningful Answer (124)

Artificial Insights — Mon, 01 Dec 2025 20:30:09 GMT

Welcome back to Artificial Insights, where the ongoing experiment in thinking out loud with machines keeps unfolding in public.

The Quiet Discipline of Great Engineering Teams

CodeKraft — Mon, 01 Dec 2025 16:00:00 GMT

I’ve seen these patterns repeat across every engineering organization I’ve worked with—from fast-moving startups to massive, multi-cloud systems. The fundamentals don’t change, no matter the scale. Stability is invisible when it works and unforgettable when it fails. Great engineering teams know this, which is why they treat fundamentals as their operating system—not a side project. Availability, security, quality, and performance aren’t checkboxes. They’re the disciplines that keep teams fast, customers confident, and innovation moving.

Minipost: Olmo 3 training cost

Muxup — Mon, 01 Dec 2025 14:00:00 GMT

Recently I jotted down some notes on LLM inference vs training costs for DeepSeek and I wanted to add on an additional datapoint for training cost based on the recently released Olmo3 models from the Allen Institute for AI ("Ai2"). The model family has 7B and 32B parameter models, with 'Think' variants available for 7B and 32B but so far only a 7B 'Instruct' non-reasoning version (but watch this space). What's particularly interesting about the Olmo models to me is that beyond providing open weights, the training scripts and datasets are openly available as well.

Going by the reported benchmarks at least it's competitive with less open models at a similar size, and importantly they've increased the supported context length from the rather limiting 4k tokens supported by the Olmo 2 series to a much more usable 64k tokens. Given the relatively small size these models are less capable than relatively chunky models like DeepSeek R1/V3.x or Kimi K2, but I've been impressed by the capability of 32B dense models for basic queries, and from my non-scientific testing both the 32B and 7B Olmo3 variants seem to do a reasonable job of summarising things like discussion threads. You can experiment yourself at playground.allenai.org.

Energy required for training Olmo 3

One of the neat things about this level of openness is that it should act as a floor in terms of performance for future models of this size class assuming they're appropriately funded and don't take too many risks chasing novelty. Rerunning the training process with an updated dataset and some minor tweaks is something you could imagine doing on some regular cadence, ideally as a shared endeavour. Imagining this effort in the future, how much energy is required? The initial version of the detailed Olmo 3 technical report unfortunately has little to say on this. We can get a back of the envelope figure in terms of GPU hours for pre-training based on the reported 7700 tokens per second per GPU for the 7B base model and 1900 tokens per second for the 32B base model and the ~6T token dataset. But even better than that, we can just ask the Ai2 folks (sometimes the internet really does work wonderfully!). After asking on their public Discord I was rapidly furnished with this helpful answer:

For some detailed numbers, we measured power consumption throughout training, along with total GPU hours. We used ~234k H100 hours to pretrain the 7B, and ~1.05m H100 hours to pretrain the 32B. 1900 TPS is generally what our trainer is capable of, but with restarts, evaluations, checkpointing, and occasional network issues, the 32B took 1.05m hours. We measured an average power consumption of ~621W while pretraining the 7B and ~649W while pretraining the 32B, and this means that our GPUs consumed ~146MWh for the 7B and ~681MWh for the 32B. We'll include more detailed GPU hour information in a future version of the paper, including for post-training!
Ai2 Olmo 3 team on their Discord.

So that's 0.681 GWh in GPU power draw for pretraining the 32B model and 0.146 GWh in GPU power draw for pretraining the 7B model. As noted in the quote, this is inclusive of restarts, checkpointing etc. But perhaps won't include previous early stage experimentation. I look forward to an updated technical report with full details, but pretraining should cover the bulk of the compute requirements (as a reference point, today's DeepSeek V3.2 paper found it notable that the post-training compute budget exceeded 10% of the pretraining cost).

The 0.681 GWh figure doesn't account for full system power and cooling cost. I'd love to be corrected, but I believe a 1.5x-2x multiplier would be an assumption towards the upper end. But for the sake of this yardstick comparison let's look at a few comparisons based on the reported number:

0.681 GWh of electricity would cost about £180k at UK residential rates (capped at 26.35p per kWh currently). Substantially less in the USA.
A larger leisure centre with a pool consumes ~2.5 GWh of energy per year. I don't know if the idea of a "leisure centre" translates outside of the UK, but basically it's a swimming pool plus gym, squash/tennis courts etc.
- The linked page claims ~2 GWh of energy in gas and 0.5 GWh in electricity. For the gas, to compare like with like you'd need to consider the source of energy for the electricity used for Olmo training.
0.681 GWh is ~0.11% of LHC's annual 600 GWh energy consumption or ~0.05% of CERN's annual consumption.
We can estimate a Boeing 787-9 flying from London Heathrow to SFO consumes jet fuel containing ~0.58 GWh of energy.
- Calculated with 8638km distance, 5.62kg fuel/km (taking the most economic 787-9 long haul figure from this table on Wikipedia and 11.95kWh/kg specific energy of jet fuel).
- This is a yardstick rather than a direct comparison. A direct comparison to the GWh of electricity used for the GPU compute of the LLM would depend on the source of the electricity. If it was e.g. gas rather than solar/hydro/wind then you'd want to compare the number of GWh consumed to create that electricity which would of course be higher.
- As a further point of reference, FlightAware indicates 5 separate direct LHR to SFO flights scheduled per day.

More efficient LLM training

We can hope for new breakthroughs, more efficient hardware, better datasets and so on. But here is some work I noticed in the area. Fair warning: this isn't my field, and we have to recognise applying a research result to a production training run is sure to have challenges even if the research suggests the trade-offs are worthwhile. So consider this vague gesticulating about seemingly interesting work that is going on and find someone who knows what they're talking about to confirm the degree to which it is interesting/viable.

Mixture of Experts (MoE) models are substantially cheaper to train which is one reason the industry has moved in that direction. The next Ai2 Olmo model is expected to be MoE. The Qwen blog has a graph comparing the relative training cost in GPU hours of the dense Qwen3-32B vs Qwen3-30B-A3b vs Qwen3-Next-80B-A3B, where the latter makes further architectural changes, reporting a 10.7x reduction. ~2.5x of that is going to come from the reduced corpus size (15T tokens down from 36T), but that still leaves plenty of improvement from other factors.
Maybe it will be shown viable to train in lower precision such as MXFP8 or even NVFP4, which would allow much more throughput for a similar energy budget. Nvidia have worked to demonstrate this can be effective for both formats (see also this work from MIT).
Also from Nvidia, Nemotron Elastic showed a model architecture that allows deriving smaller models without doing a separate pre-training runs.

Finally, the cheapest way to train an LLM from scratch is...to find a way to avoid the need to. For models like Olmo 3 that release the base model and checkpoints, people can apply their own post-training or perform additional pre-training.

Bonus comparison point: Apertus

Apertus is a Swiss project to produce an open LLM, with 70B and 8B models released so far. Their full tech report notes the following "Once a production environment has been set up, we estimate that the model can be realistically trained in approximately 90 days on 4096 GPUs, accounting for overheads. If we assume 560 W power usage per Grace-Hopper module in this period, below the set power limit of 660 W, we can estimate 5 GWh power usage for the compute of the pretraining run."

Article changelog

2025-12-04: Add link to "Four Over Six" NVFP4 training paper.
2025-12-02: Added clarifying note about energy via gas in the leisure centre comparison.
2025-12-01: Initial publication date.

Project Panama from Zero to hero Part 1

David Vlijmincx — Mon, 01 Dec 2025 12:55:03 GMT

The first part where we introduce project Panama and show some of the basics. We will keep building on this knowledge in the other parts.

Generating a Minecraft map as website

kleemans.ch — Mon, 01 Dec 2025 11:00:49 GMT

I recently started playing Minecraft again with my son, and it was a ton of fun playing together, and also rediscovering all the changes in the game since I played last some years ago.

One time I was exploring the world for a bit and then died (bloody skeletons) leaving all my stuff in the middle of nowhere. After trying to find the place where I'd died, I remembered that there used to be a server mod which would generate a 2D overview of the world, so it was easier to see where things actually were, especially for someone like me who somethimes struggles with orientation.

As I am running a local, vanilla server JAR on my laptop just for the time that we are playing, I didn't want to introduce any mods, so I looked for a way to generate a map just from the world files that Minecraft had generated, and found Unmined.

With the CLI version of Unmined and a simple command (./unmined-cli image render --world="world" --output="./map.png"), it is possible to generate images like this:

Now have the whole Minecraft world as an image is already pretty cool, but zooming is a bit tedious and also the coordinates are not showing, making it a bit difficult to use besides the game.

Luckily, there's also a web parameter for the CLI, which will generate a Google Maps-like tile map, where on lower zoom levels, tiles are dynamically fetched and shown. Like this:

The map above was generated with

./unmined-cli web render --world="world" --output="generated-map" --zoomin=2

The --zoomin-parameter specifies how far the maximum zoom depth should be, and with 2 it already generated around 3'000 files. Setting it to --zoomin=3 would generate around 12k files.

Highlights

Some cool things to discover on the map above:

Cherry blossom trees

Minecart tracks showing up in yellow

Village

Abandoned portal (?)

Happy mining!

Nobody Wants This: Season 2

🦉 olshansky 🦁 — Mon, 01 Dec 2025 06:57:40 GMT

The first few episodes were slow, but it started picking up.

The first season was very “meh” in my opinion, but it passed the threshold of “good enough” to serve as a palate cleanser between more serious shows that I watch in parallel.

There are a lot of hidden lessons related to understanding yourself, your partner, finding compromise, and the fine balance of self-preservation, self-fulfillment, self-improvement, and self-sacrifice.

In between, funny moments like “Temple Ahava” being the most woke synagogue in the world, and Sasha’s dancing, serve as great moments of comic relief.

Oops, I accidentally built a Steam Machine

./techtipsy — Mon, 01 Dec 2025 06:00:00 GMT

I was longing for a Steam Deck that had more oomph. Guess Valve felt that way, too.

New York gods

Something About Cats — Mon, 01 Dec 2025 04:06:28 GMT

A transit mythology

Introducing RFC Hub

Thomas Hunter II — Mon, 01 Dec 2025 02:00:00 GMT

A new system for organizing my writing and projects

ntietz.com blog - technically a blog — Mon, 01 Dec 2025 02:00:00 GMT

Keeping up with regular blog posts is a challenge. To do it, I've churned through a few different organizational systems. Sometimes I have to change them due to actual life circumstances changing; other times, due to the old one just wearing off^[1].

Well, my life circumstances have changed again. I'm on medical leave right now recovering from surgery^[2], and I have been writing less this year anyway. So it's that time again: new system, baby.

This post isn't a how-to. It's not a prescription for your own organizational system. Rather, let it be an invitation to examine your own systems, and decide whether they're serving you or not.

Out with the old

So what am I replacing?

Before this change, my system involved Obsidian and LunaTask:

Obsidian for recording ideas
LunaTask for keeping track of works in progress and things that have a due date

When I get an intrusive thought about how I definitely need to try to make a transistor at home in my garage^[3], I put that in my list of ideas. This list of ideas contains some ridiculously bad ideas, and some very good ideas. But the thing is, I can't tell which is which when I have the idea! The ideas have to sit and marinate, and then eventually one sticks in my head long enough that it turns itself into a blog post. With most of the already completed ideas removed, that file is over 150 lines long right now.

LunaTask is used to get these ideas from my brain over the finish line. I have a project called "Writing" which is kanban style. Each blog post I earnestly intend to write gets added into it, and then I keep track of which ones are waiting, in progress, and completed. This is mostly useful for posts which require code to go along with them, or which require research^[4]. Posts like this one that are all prose without research go pretty fast and never enter LunaTask.

The thing is, this has been showing cracks. I've stopped recording blog post ideas all that much this year, because I've been stressed from "global events" (I'm a trans woman, my wife is an immigrant, etc.) and preparing for multiple surgeries. And tracking things in LunaTask is just not working for me at all, because it's disconnected from idea tracking but ends up being its own idea tracking, since I just really want to write all the posts.

To be honest, I'm not 100% sure why LunaTask isn't working for me right now for this. It might just be that I need to perturb the system a bit to make a change. But no matter what the cause, it's time to change it.

In with the new

The new system is simpler than the old, because I'm removing a tool. I'm taking LunaTask out of my blog toolkit, and switching to tracking everything in Obsidian.

The new system is going to be smaller:

an ideas page in Obsidian
a works-in-progress page
a task tracker for recurring blog tasks

I'm using a task tracking plugin in Obsidian for the recurring tasks, because there are some things I need to do on a regular schedule. If I want to publish on Monday, that means that the post needs to be written before the weekend and edited before Monday.

I'm not using task tracking for actual posts because I know from personal experience that it ends up similar to my ideas page but with structure. I'm also not using Obsidian's Bases for this, because a raw text file is just the lowest friction way I've found to do what I need. A raw text file lets me move things around freely, add notes however and wherever I want, and do freeform brain dumps. Structure is a little tyrant that kills my motivation at certain phases, so bye bye structure, we're doing a coup here.

* * *

So far, so good with the new system. I'm sure I'll be onto another one eventually. The most important thing, I've found, is to remain mindful of whether or not the systems are working for you. Change them once they stop working.

There's this phenomenon where self-help productivity books almost always help you when you adopt a new system. But the help doesn't last forever! It seems that changing your system helps in some way, perhaps from the increased awareness and mindfulness, or maybe from new dopamine. ↩
It was a planned gender affirming surgery. The recovery is long and challenging, but I'm recovering very well. I'm very thankful for the support I have from my friends, family, and community. ↩
How hard can it be? The hubris of a software engineer knows no bounds, except for that refactor you know you should do but that you think is just a little too hard. (And yes, making a transistor would be very hard, and no, I'm not going to do it. Probably. The thoughts are still here.) ↩
I have a partially written post on Lyme disease which I do intend to complete, but it's a topic that I really want to be careful around. And so it languishes. ↩

Podcast Recommendations

Zappable — Mon, 01 Dec 2025 00:22:34 GMT

In honor of Thanksgiving weekend and the end of the year, these are some podcasts I enjoy along with recommended episodes from them.

Custom CNC Desktop Mark II

Pete's Points — Sun, 30 Nov 2025 23:24:39 GMT

I made another custom desktop on the CNC with recesses for my split keyboard. I'm really happy with how it came out. I got the project finished up and installed over the Thanksgiving holiday break, and my wife painted two of the walls in my office - one has a logogram from the movie "Arrival", and the other is a geometric pattern. All this adds up to make my office looking and feeling so much nicer now!

custom desktop mark II

low angle shot showing the recess depth

center view

Arrival Logogram Artwork

The movie "Arrival" contains my all-time favorite visual effect. The alien writing system, referred to as logograms in the movie, are these strikingly beautiful circular smoke patterns. I thought it would be a great thing to put in my office and make an awesome background for video calls. My wife has done a few paintings directly on the walls using a projector to establish a baseline pencil sketch. So that's what she did and it came out great. On another wall I was inspired by a nearby commercial building with a geometric mountain pattern, and she did that on the adjacent wall.

Arrival logogram artwork: Louise has question

view of whole office with geometric wall pattern, Arrival art, and desktop setups for my work and personal workstations

Mark I was made of 3 layers of MDF. For this version, with more CNC & CAM experienced, I realized I could get by with 2 layers by treating them like a sandwich and milling out the interior of both slices. So I milled the cable channels into the top piece by placing it into the CNC upside down. This also means the final assembly is 1" thick and lighter weight.

I have been bumping my swivel chair into the armrests a bit, so I shrunk those down a few inches to hopefully reduce that.

I moved the coffee recess back a bit to try to leave full thickness in the center where my flexispot desk has 4 screws for attaching the desktop to the base. In the end there's only clearance for 2 of the 4 screws, which is better. I just omit the other 2 screws because installing them they would poke up into the coffee mug recess because there's only about 1/4" of material at that position.

I did a roundover on the edge to hopefully make it a bit more durable against dings.

Even though the desktop overall is thinner, I had a bigger depth to work with for the keyboard recess, so they are recessed quite a bit deeper such that most of the keycaps are below the desktop surface. Only the tilted angle keycaps stick out of the recess by a tiny bit at their tips.

Ergonomics and typing video

Here's videos of me typing at the desk both seated and standing.

Failures

I did a CNC attempt with 1/2" plywood. It did not cut well due to layers wanting to chip and splinter. That model had the cable channels too deep and the bottom of them too thin, so there was huge chunks that just exploded out entirely during CNC and it was an irrecoverable failure. After that I decided to go back to MDF which mills very consistently and nicely.

I had several CAD and CAM issues this time around. Even more than the first one which was unexpected.

I forgot to add tabs and had the dreaded projectile cutout situation at one point. Nothing went beyond the surface of the CNC though so no injuries.

In the revised CAD for this, I made a square at 7" per side. Then I filleted the corners in the sketch. And for some reason when that happens, FreeCAD drops most of the dimension constraints. I re-added the 7" dimension to the y axis but forgot to re-add it to the x-axis. So I ended up with rectangles 7" by 6.69" very unexpectedly. Definitely a head scratcher when the keyboard insert didn't fit by a large margin. As a workaround, I had to adjust the 3D print to match those dimensions, and luckily there's enough extra space to still fit the keyboard.

The deep recess meant my thumb would hit the edge of the keyboard holder insert, so I had to adjust the model to remove the wall there to make clearance.

Heading back to work tomorrow after the holiday break should be a lot more pleasant and inspiring surrounded by cool art and furniture I made to be highly tailored to me.

2025.11.DisappearingMoment

Disappearing Moment — Sun, 30 Nov 2025 23:10:49 GMT

Imagine that you and I were the subject of an experiment. We let researchers place us in comas on November 1, 2017. They awakened us eight years later.

We’ve spent the past month observing and being observed. Learning what we missed. Seeing family, friends, neighbors, and colleagues.

What would have surprised you the most? What would have required the biggest adjustment?

Politics and sports are about what I expected. While I wouldn’t have anticipated the rise of pronouns or polyamory, I’d adjust to them quickly. Same with AI, which takes as much adjustment time as special effects in a movie. Cryptocurrency, NFTs, meme stocks, and other financial news: Meh.

What I’d need more time with is our openness about mental health and the ways we medicate ourselves. Which is a long way of saying, I’m still getting used to it. Even without having been in a coma.

I’m not objecting or judging. It’s a net positive that everyone I know has disclosed, often as I sit in an audience, that they’re autistic or have ADHD. Or depression, anxiety, trauma, OCD, hyper- or hypothyroidism, disordered eating or eating disorders. It’s good not to feel ashamed.

I’m also still getting used to the ways we medicate. The number of people I know who have at least one drink almost every day. Or consume cannabis almost every day (or many times per day). Who rely on nicotine or caffeine. Who microdose psychedelics (or dose on a regular basis). SSRIs or other antidepressants. Adderall or Ritalin or other stimulants. Vitamins or supplements for mood, focus, equanimity.

I don’t know how causes or prevalence compare to other times in history. Is this knowable? Does it matter?

What feels different are the norms and rituals, the expectations and transactions. I hope it’s helping.

Welcome to November 2025’s Disappearing Moment, an inventory of my experiences. I hope it's helping, too.

Podcasts

“Bored and Brilliant” series (Note to Self) (I Liked It): Media and technology are drugs, drugs, drugs.
Underfoot (I Loved It): It was Catipalism all along.

Nerdy Software

I’ve replaced Pinboard.in with Linkding. I use Cloudbreak for hosting. I’m lost without a bookmark manager.

Free Font

FiraGo is independent, free, beautiful, international, and popular.

Bougie Products

When we eat at home, we use cloth napkins at every meal. Beth and I are worth it, and so are our guests.

Personal Finance and Investing

Raspberry's Risk-Based Guardrails Calculator is an Excel file. It helps you plan your retirement (i.e., what you can spend).

Reading

John Buck, “Mr. Tiff” (I Liked It): Stay for the payoff.
David Bushell, “XSLT.RIP” (A Personal Favorite): Your monthly reminder that Goooooooooogle suuuuuuuuuucks.
Keira D’Amato, Don’t Call It a Comeback (2025) (I Liked It): It seems that my favorite genre is Memoirs by Runners. Come for the motivation, stay for the dad jokes.
Kieran Healy, “Trustworthy Data Visualization” (I Loved It): “(I)n a world where researchers are faking results, AIs are enthusiastically confabulating, and government is destroying data infrastructure....”
Filipa Mendonça-Vieira, “In Praise of dhh” (I Liked It): “Spending all day talking to smart, brilliant people, who are afraid of ever contradicting you is a recipe for melting your brain.”
Mike Monteiro, “How to avoid listening to Radiohead” (I Loved It): “...not only is that okay, it’s necessary in a relationship. Part of being together is having things that you enjoy doing by yourself.”

Survey

To see the survey and respond to it, you have to subscribe via email and answer it through an email interface.

Last month’s question: “How many poems do you read each year?” There were four responses. Two of you read more than 50. One person reads 26–50. One person reads 1–5. I read 11–25: the poems in Laura Olin’s newsletter, plus a few others.

Literary Journal

The Adroit Journal has come a long way in less than 15 years. If you treat your writers and readers well, good things happen.

Not Unless I’m Asked

Accent, observations about theirs or mine
Appearance, critiques about theirs or mine
Athletic accomplishments (mine) (such as they are)
Children (including nieces and nephews), accomplishments or complaints
Dreams (that I had while sleeping)
Investments
Pets, stories about mine
Politics
Sports, real or fantasy
Where I live or have lived, quirks thereof

Thank you for spending a few moments with me. I appreciate you and look forward to corresponding again next month.

Brett

Want to discuss this newsletter or anything else with other Disappearing Moment readers? Please sign up for Perpetual August. It might be fun.

The Doorman

Alejandro AR (kinduff) — Sun, 30 Nov 2025 22:30:00 GMT

Carding the CEO is the ultimate unit test.

What makes a good egg?

De Novo — Sun, 30 Nov 2025 18:45:30 GMT

Desiderata for in vitro oogenesis

Why I Built My Own Kubernetes Cluster

Onat Mercan’s Blog — Sun, 30 Nov 2025 14:00:00 GMT

Minipost: Benchmarking the Hetzner AX102 vs CCX53

Muxup — Sun, 30 Nov 2025 14:00:00 GMT

I recently had reason to do a quick comparison of the performance of the Hetzner AX102 dedicated server and the high-end 'dedicated' CCX53 VPS on Hetzner Cloud and thought I may as well write up the results for posterity. I'm incapable of starting a post without some kind of disclaimer so here comes the one for this post: naturally the two products have major differences in terms of flexibility (spin-up/down at will, vs pay a small setup fee and endure a wait time depending on hardware availability). So depending on your use case, your requirements with respect to that flexibility may override any cost differential.

Specs

All costs are exclusive of VAT, assuming the lowest cost data center location, and inclusive of IPv4 address.

AX102:

16 core Ryzen 9 7950X3D (32 threads)
128GB DDR5 RAM
2 x 1.92TB NVMe
104 EUR/month, 39 EUR one-off setup fee.

CCX53

Unknown AMD CPU exposing 32vCPU (physical cores? threads?)
128GB RAM
600GB NVMe
192.49 EUR/month maximum charge. 0.3085 EUR per hour (if you keep the same VPS active over the month it won't exceed the monthly price cap, so you effectively get a small discount on the per-hour cost).

Benchmark

Building Clang+LLVM+LLD, everyone's favourite workload! Both systems are running an up to date Arch Linux (more details on setting this up on the CCX53 in the appendix below) with clang 21.1.6. The dedicated machine has the advantage of RAID 0 across the two SSDs, but also has encrypted rootfs configured. I didn't bother to set that up for the CCX53 VPS.

sudo pacman -Syu --needed clang lld cmake ninja wget
LLVM_VER=21.1.6
wget https://github.com/llvm/llvm-project/releases/download/llvmorg-${LLVM_VER}/llvm-project-${LLVM_VER}.src.tar.xz
tar -xvf llvm-project-${LLVM_VER}.src.tar.xz
cd llvm-project-${LLVM_VER}.src

cmake -G Ninja \
  -DLLVM_ENABLE_PROJECTS='clang;lld' \
  -DLLVM_TARGETS_TO_BUILD="all" \
  -DLLVM_CCACHE_BUILD=OFF \
  -DCMAKE_C_COMPILER=clang \
  -DCMAKE_CXX_COMPILER=clang++ \
  -DLLVM_ENABLE_LLD=ON \
  -DCMAKE_BUILD_TYPE=Release \
  -DLLVM_ENABLE_ASSERTIONS=ON \
  -S llvm \
  -B build
time cmake --build build

printf "### Version info ###\n"
clang --version | head -n 1

On both machines, ninja shows 5575 build steps.

Results:

AX102
- 10m27s (627s)
CCX53
- 14m11s (851s, about 1.36x the AX102)

Running the clang and LLVM tests with ./build/bin/llvm-lit -s --order=lexical llvm/test clang/test (which shows 9402 tests) gives:

AX102
- 3m39s (219s)
CCX53
- 4m28s (268s, about 1.24x the AX102)

I ran these multiple times, and in the case of the CCX53 across two different VMs in different regions and saw only a few percentage points variance.

Focusing on the results for build clang/llvm/lld, let's figure out the cost for 1000 from-scratch builds. Not so much as it's a representative workload, but because it gives an easy to compare metric that captures both the difference in price and in performance. So calculating time_per_build_in_hours * 1000 * cost_per_hour:

AX102
- (626.6 / 3600) * 1000 * (104/720) = 25.14 EUR
- Or if you include the setup fee and assume it's amortised over 12 months:
  - (626.6/3600) * 1000 * ((104 + (39/12))/720) = 25.93 EUR
CCX53
- (850.6 / 3600) * 1000 * (192.49/720) = 63.17 EUR
- Or using the 0.3085 EUR/hr price which you would pay if you didn't run for the whole month:
  - (850.6 / 3600) * 1000 * 0.3085 = 72.89 EUR

Appendix: CCX53 Arch Linux setup

This could be scripted, but I just created the VPS via their web UI. Then after it was provisioned, used that web UI to have it boot into a rescue system. Then do an Arch bootstrap that roughly mirrors the one I use on a dedicated build machine except that we don't bother with encrypting the rootfs. The CCX* server types at least use UEFI so we can keep using efistub for boot.

First get a bootstrap environment and enter it:

wget http://mirror.hetzner.de/archlinux/iso/latest/archlinux-bootstrap-x86_64.tar.zst
tar -xvf archlinux-bootstrap-x86_64.tar.zst --numeric-owner
sed -i '1s;^;Server=https://mirror.hetzner.de/archlinux/$repo/os/$arch\n\n;' root.x86_64/etc/pacman.d/mirrorlist
mount --bind root.x86_64/ root.x86_64/ # See <https://bugs.archlinux.org/task/46169>
printf "About to enter bootstrap chroot\n===============================\n"
./root.x86_64/bin/arch-chroot root.x86_64/

Now set info that will be used throughout the process:

export NEW_HOST_NAME=archvps
export PUBLIC_SSH_KEY="ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOfpPQ1j+XLsapAhONAQmvu6TZGT5y8jeziM4Vio1NrA asb@plurp"
export NEW_USER=asb

And now proceed to set up the disks, create filesystems, perform an initial bootstrap and chroot into the new rootfs:

pacman-key --init
pacman-key --populate archlinux
pacman -Sy --noconfirm xfsprogs dosfstools

sfdisk /dev/sda <<EOF
label: gpt

start=1MiB, size=255MiB, type=uefi
start=256MiB, type=linux
EOF

mkfs.fat -F32 /dev/sda1
mkfs.xfs /dev/sda2

mount /dev/sda2 /mnt
mkdir /mnt/boot
mount /dev/sda1 /mnt/boot
pacstrap /mnt base linux linux-firmware efibootmgr \
  xfsprogs dosfstools \
   python3 \
  openssh sudo net-tools git man-db man-pages vim
genfstab -U /mnt >> /mnt/etc/fstab

printf "About to enter newrootfs chroot\n===============================\n"
arch-chroot /mnt

Do final configuration from within the chroot:

sed /etc/locale.gen -i -e "s/^\#en_GB.UTF-8 UTF-8.*/en_GB.UTF-8 UTF-8/"
locale-gen
# Ignore "System has not been booted with systemd" and "Failed to connect to bus" error for next command.
systemd-firstboot --locale=en_GB.UTF-8 --timezone=UTC --hostname="$NEW_HOST_NAME"
ln -s /dev/null /etc/udev/rules.d/80-net-setup-link.rules # disable persistent network names

# No longer need to disable large fallback image as Arch stopped generating it
# by default

printf "efibootmgr before changes:\n==========================\n"
efibootmgr -u
# Set up efistub
efibootmgr \
  --disk /dev/sda \
  --part 1 \
  --create \
  --label 'Arch Linux' \
  --loader /vmlinuz-linux \
  --unicode "root=/dev/sda2 rw initrd=\initramfs-linux.img" \
  --verbose
printf "efibootmgr after changes:\n=========================\n"
efibootmgr -u

mkswap --size=8G --file /swapfile
cat - <<EOF > /etc/systemd/system/swapfile.swap
[Unit]
Description=Swap file

[Swap]
What=/swapfile

[Install]
WantedBy=multi-user.target
EOF
systemctl enable swapfile.swap

cat - <<EOF > /etc/systemd/network/10-eth0.network
[Match]
Name=eth0

[Network]
DHCP=yes
Address=$(ip -6 addr show dev eth0 scope global | grep "scope global" | cut -d' ' -f6)
Gateway=$(ip route show | head -n 1 | cut -d' ' -f 3)
Gateway=fe80::1
EOF
systemctl enable systemd-networkd.service systemd-resolved.service systemd-timesyncd.service
printf "PasswordAuthentication no\n" > /etc/ssh/sshd_config.d/20-no-password-auth.conf
systemctl enable sshd.service
useradd -m -g users -G wheel -s /bin/bash "$NEW_USER"
usermod --pass='!' root # disable root login
chmod +w /etc/sudoers
printf "%%wheel ALL=(ALL) ALL\n" >> /etc/sudoers
chmod -w /etc/sudoers
mkdir "/home/$NEW_USER/.ssh"
printf "%s\n" "$PUBLIC_SSH_KEY" > "/home/$NEW_USER/.ssh/authorized_keys"
chmod 700 "/home/$NEW_USER/.ssh"
chmod 600 "/home/$NEW_USER/.ssh/authorized_keys"
chown -R "$NEW_USER:users" "/home/$NEW_USER/.ssh"

Now set password:

passwd "$NEW_USER"

Then ctrl-d twice and set a symlink for resolv.conf:

ln -sf ../run/systemd/resolve/stub-resolv.conf root.x86_64/mnt/etc/resolv.conf

Finally, reboot.

Remember to ssh-keygen -R $THE_IP_ADDRESS so you don't get ssh host verification errors.

Article changelog

2025-11-30: Initial publication date.

Windows drive letters are not limited to A-Z

ryanliptak.com — Sun, 30 Nov 2025 02:00:00 GMT

If you want €:\, you can have it, sort of

Bending Emacs - Episode 7: Eshell built-in commands

xenodium.com @alvaro — Sun, 30 Nov 2025 02:00:00 GMT

With my recent rinku post and Bending Emacs episode 6 both fresh in mind, I figured I may as well make another Bending Emacs episode, so here we are:

Bending Emacs Episode 7: Eshell built-in commands

Check out the rinku post for a rundown of things covered in the video.

Want more videos?

Liked the video? Please let me know. Got feedback? Leave me some comments.

Please go like my video, share with others, and subscribe to my channel.

If there's enough interest, I'll continue making more videos!

Make it all sustainable

Enjoying this content or my projects? I am an indie dev. Help make it sustainable by ✨sponsoring✨

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

Setting up Epithet as of v0.1.7

Brian's Waste of Time — Sun, 30 Nov 2025 02:00:00 GMT

The Goal

We want to set up a real epithet system, end to end, and use it. Because everything is self hosted, there are a number of steps:

Install epithet on your local Mac
Configure an SSO provider
Set up CA and Policy services
Configure the epithet agent
Create a cloud-init config for new VMs to rely on the CA
Actually SSH to the VM!
Run epithet as a daemon
Cleaning up config and playing around

Prerequisites

Have tofu and awscli installed. Make sure you have configured awscli. You will need to run this on a machine capable of spawning a web browser you interract with, so if you are doing it on a VM or such, do it under X (or Wayland, VNC, etc). The article assumes you are on a Mac, because I am, but it should adapt alright if you are on a flavor of linux or whatnot. I have not tried any of this on Windows yet. If it works, let me know!

Install epithet on your local machine

As mentioned, I'm working on a Mac, and use Homebrew, so this article is kind of oriented around that:

brew install epithet-ssh/tap/epithet

If you are not on a mac, or not using homebrew, you will need to build and install it yourself. Clone epithet and check out v0.1.7 which is the version this article is written against. It's implemented in Go, so you'll need that installed. You can build it with make:

git clone https://github.com/epithet-ssh/epithet/
cd epithet
git checkout v0.1.7
make epithet # or just `make` if you want to run the tests

If you built it youself, put the binary somewhere on your $PATH. If you don't have it on your $PATH, later stuff we do will be trickier, and changing the examples to use the full path is an exercise left to you.

Configure an SSO provider

We'll use Google for SSO, but you could as easily use Microsoft, Apple, AWS (Cognito), Facebook, Github, Gitlab, Okta, Yahoo!, Keycloak, Authentik, and so on. OIDC/OAuth2 is pretty widespread nowadays, and you don't need a full IDP (ie, a full SCIM provider) for Epithet, just someone to provide identity at the other end of OIDC. I'm using Google because GMail is widely used, so it is useful for many people.

Go to Google Cloud Console
Select or create a project
Navigate to APIs & Services → Credentials
Configure a consent screen
Add a name for your App, I used "Epithet Demo"
For Audience, if you are using Google Workspace you can make it Internal and be good to go. If using general GMail, then make it External. I am making this demo External.
This dropped me on a screen with a "Create OAuth Client" -- which I picked. If you are getting there differently it is fine, you need to create an OAuth Client/Credential.
Choose Application type: I use Universal Windows Platform (UWP). Despite the name, it is not limited to Windows apps, and it does PKCE. "Desktop App" does not support PKCE, so you need to embed the OAuth secret in the agent config. The internet tells me this is fine, and secure, and the secret is not really a secret. I want to just use PKCE, so I use UWP here.
Enter a name: I used "Epithet Agent"
If you are using UWP you will need to include a Store ID, I don't believe it is used anywhere. I used "epithet-demo"
Click Create
Make note of the Client ID.
Select the "Audience" tab on the left.
In the "Test Users" section add a couple users (email addresses) who you want to be able to use the app. I added a couple google accounts I have, a general public one which I am using to set up this demo, and a Workspace email that I actually use for things. I set up two so that I can configure different policies for them later. If you created an "Internal" app type earlier, you can skip this step -- your Workspace users should be able to use the app automagically.

You can test the configuration using the epithet auth oidc command:

echo "" | epithet -vvv auth oidc --issuer=https://accounts.google.com --client-id=<OAUTH_CLIENT_ID> 3>/dev/null

Note, use your client id, not the <OAUTH_CLIENT_ID> placeholder. Also note the echo "" | at the beginning and 3>/dev/null at the end: these are for epithet's auth plugin protocol, which expects input on stdin and to write state to FD 3. This should pop up the authentication flow and if you log in will let you know it was successful and show you the auth token.

In my case, it was successful, so I am moving on!

Set up CA and Policy services

These are generally low volume things which are more or less perfect use cases for FaaS platforms. Because AWS is the most popular I made Lambda wrappers for epithet's built in basic CA and Policy services. Start by cloning the repo for them, which contains the terraform (tofu) configs to actually set them up (as well as the wrapper code if you want to play with it). I set it up as a template repo, so you can use the "Use this template" to clone it in Github if you like. Make sure to set the privacy to "Private" if you do -- it can be public, but Github will complain about you checking in your OAuth Client ID if you do.

git clone https://github.com/epithet-ssh/epithet-aws epithet-demo
cd epithet-demo

Configuring the Policy Server

Now, let's do some basic configuration for the deployment. We do this with some terraform variables, created and edit terraform/terraform.tfvars:

aws_region     = "us-east-1"
project_name   = "epithet-demo"

I am using us-east-1 for the demo (unofficial designated demo region) and picked a name (epithet-demo).

Now we need to make a basic policy for the Policy service. It should be in config/policy.yaml. I'm going to use:

# CA public key is loaded from SSM Parameter Store at runtime
# This placeholder satisfies config validation
ca_public_key: "placeholder - loaded from SSM"

oidc:
  issuer: "https://accounts.google.com"
  audience: "<OAUTH_CLIENT_ID>"

users:
  "brianm@skife.org": ["wheel"]
  "brian.mccallister@gmail.com": ["dev"]

defaults:
  allow:
    arch: ["dev", "wheel"]
  expiration: "5m"

#hosts:
#  "prod-*.example.com":
#    allow:
#      deploy: ["dev"]
#    expiration: "2m"

Let's talk about what it does and how it works.

The Policy server needs the CA's public key in ca_public_key as it validates requests that come with it (the CA signs them using the CA private key). For the Lambda wrapper we load the public key from AWS's config service (SSM) so the actual configuration value is ignored.

The oidc section needs to know the provider URL (issuer) and the client id (called audience here, for OIDC reasons). Put your client id for the audience attribute.

The users section configures allowed users. The built-in Policy server uses static configurations, so it needs to know which users are allowed to use it, up front. Additionally, it uses a group-style matching system and assumes that "remote-user == principal". For demo purposes I use two groups, wheel and dev, but that choice is arbitrary. It also has no relationship to actual unix groups on the hosts -- it is purely used internally for matching users to principals in the policy server. I configured two users so I can mess around later and experiment.

The defaults section establishes defaults for host configuration. In this case it gives the arch principal to anyone in the dev or wheel group, unless overridden for a specific host. We also set up a 5 minute expiration for certificates.

Finally, the hosts section lets you do per-host configration. It is a map of host-glob -> config. I have it commented out for now, but am leaing it as a reminded for playing around later.

This overall config means that, assuming one of the users authenticates successfully (which it checks), it will issue a cert for any remote host and remote user with the arch principal. I used that principal because I am going to use Arch Linux cloud images to test things, and those provision the arch user by default.

Deploy the services

I am not going to step through setting up a new AWS acount for you, so I'll prefix this next section by saying -- have an AWS account, and have the aws-cli configured to use it!

make init
make apply

Watch tofu set up a pile of stuff in AWS:

API Gateway for CA
API Gateway for Policy
IAM policies
Secret to hold the private key
SSM to hold the public key
S3 bucket to keep certificate log in
Other stuff, look in terraform/ of the repo you cloned for everything. I believe there are 32 things total it sets up.

When it is finished it will spit out a bunch of information for you:

ca_public_key = <sensitive>
ca_public_key_command = "aws ssm get-parameter --name /epithet-demo-9230323c/ca-public-key --query Parameter.Value --output text"
ca_public_key_parameter = "/epithet-demo-9230323c/ca-public-key"
ca_secret_arn = "arn:aws:secretsmanager:us-east-1:378899212612:secret:epithet-demo-9230323c-ca-key-encO9c"
ca_secret_name = "epithet-demo-9230323c-ca-key"
ca_url = "https://ir6kilkap3.execute-api.us-east-1.amazonaws.com/"
cert_archive_bucket = "epithet-demo-9230323c-cert-archive"
cert_archive_bucket_arn = "arn:aws:s3:::epithet-demo-9230323c-cert-archive"
policy_url = "https://e2np6k2uj5.execute-api.us-east-1.amazonaws.com"
region = "us-east-1"

Save this info somewhere, you will need the CA URL later, and you may want to poke around the S3 bucket where info about issued certs is stored, or look at the various logs.

But we are not done, we need to actually make the CA key and upload it:

make setup-ca-key

We have to create the key pair after we provision everything else because we need the Secret and SSM to be created in AWS before we can put the private and public keys in them respectively.

You can test if the CA is running by issuing a GET to it, it should return the public key:

epithet-demo took 3s [!?] on  main ❯ xh GET https://ir6kilkap3.execute-api.us-east-1.amazonaws.com/
HTTP/2.0 200 OK
apigw-requestid: U35tYhMyoAMEcRw=
content-length: 81
content-type: text/plain
date: Sun, 30 Nov 2025 20:03:46 GMT

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIiLCOTQVHFqu7zP5j3KCjrfYavXqk7wasuckA6QvQgP

epithet-demo [!?] on  main ❯

I should probably put the same kind of smoke test on the policy server, now that I think about it.

Despite having made a pile of AWS resources, most of them are cheap and idle, so for a couple of users authenticating a few times a day, it should cost under a dollar a month. Sometimes the cloud is kind of cool.

Configure the epithet agent

Okay, we have the system up, let's configure our agent to use it! Epithet uses ~/.epithet/ for its various configs and running stat. Yes, this is not XDG style. I am open to XDG, but this seems simpler and is not totally unexpected.

cd ~/.epithet
$EDITOR ./config

Add content like:

ca-url      <Your CA URL>
match       *
auth        epithet auth oidc --issuer https://accounts.google.com --client-id <YOUR OAUTH CLIENT ID>

This config is fine for testing, for now, but the match * line is not something we'll want to leave in long term -- it is telling epithet that it should be used for every attempted connection, which we probably don't want. Once we have a VM or three to try against, we'll constrain it down.

We also need to tell SSH to use epithet, to do this we drop a line in ~/.ssh/config:

Include ~/.epithet/run/*/ssh-config.conf

Do this somewhere near the top, and definitely before anywhere you might set up an ssh agent socket.

Now, to debug we will start the agent manually -- run:

epithet -vvv agent

You should get some debug log output.

Create a cloud-init config for new VMs to rely on the CA

cloud-init

So the easiest way I have found for basic setup of a new vm is cloud-init, every major distribution and provider supports it, including my favorite, vm-bhyve (which is not really a major provider, but what I use to manage VMs on my machines).

We'll make a user-data config for cloud-init which configures sshd to respect our CA key. Make a file named user-data in your current directory which contains:

#cloud-config
resize_rootfs: True
manage_etc_hosts: localhost
write_files:
  - path: /etc/ssh/epithet_ca.pub
    content: |
      ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIiLCOTQVHFqu7zP5j3KCjrfYavXqk7wasuckA6QvQgP
    owner: root:root
    permissions: '0644'

  - path: /etc/ssh/sshd_config.d/100-epithet.conf
    content: |
      TrustedUserCAKeys /etc/ssh/epithet_ca.pub
    owner: root:root
    permissions: '0644'

But instead of using the public key for my CA (ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIIiLCOTQVHFqu7zP5j3KCjrfYavXqk7wasuckA6QvQgP) use the one for your CA.

This creates two files in /etc/ssh/ -- one with the public key, and one which tells sshd to trust that public key.

A VM

Okay, so we have a CA, an agent, and some cloud-init config, but we still need a server to use it on. Since we have used AWS so far, let's keep using it. Sadly, EC2 is pretty painful for basic VM setup nowadays. That said, we'll do it.

For this, I am going to set up in a region I never use, so that I have to do things from scratch. Clean slate makes for good demo. If you have a VPC you like, which allows SSH ingress, then you can skip the setup for the most part and just spin up your instance there. If not, hang on, we have some AWS to do.

I am going to us us-east-2 because I have never used it before. If you pick a different region you will need to find the Arch AMI for that region. You can find them at arch-ami-list.drzee.net. For us-east-2 the AMI is ami-0c87f4f769e675bf8.

If you are in bash or a regular sh:

# Create a default VPC (if one doesn't exist)
aws ec2 create-default-vpc --region us-east-2

# Create security group for SSH
sg_id=$(aws ec2 create-security-group \
  --region us-east-2 \
  --group-name ssh-access \
  --description "SSH access" \
  --query 'GroupId' --output text)

# Allow inbound SSH
aws ec2 authorize-security-group-ingress \
  --region us-east-2 \
  --group-id $sg_id \
  --protocol tcp \
  --port 22 \
  --cidr 0.0.0.0/0

# Launch the instance
instance_id=$(aws ec2 run-instances \
  --region us-east-2 \
  --image-id ami-0c87f4f769e675bf8 \
  --instance-type t3.micro \
  --security-group-ids $sg_id \
  --user-data file://./user-data \
  --query 'Instances[0].InstanceId' --output text)

# Wait for it to be running
aws ec2 wait instance-running --region us-east-2 --instance-ids $instance_id

# Get the public IP
ip=$(aws ec2 describe-instances \
  --region us-east-2 \
  --instance-ids $instance_id \
  --query 'Reservations[0].Instances[0].PublicIpAddress' --output text)

echo $ip

If you are in fish, like me:

# Create a default VPC (if one doesn't exist)
aws ec2 create-default-vpc --region us-east-2

# Create security group for SSH
set sg_id (aws ec2 create-security-group \
  --region us-east-2 \
  --group-name ssh-access \
  --description "SSH access" \
  --query 'GroupId' --output text)

# Allow inbound SSH
aws ec2 authorize-security-group-ingress \
  --region us-east-2 \
  --group-id $sg_id \
  --protocol tcp \
  --port 22 \
  --cidr 0.0.0.0/0

# Launch the instance
set instance_id (aws ec2 run-instances \
  --region us-east-2 \
  --image-id ami-0c87f4f769e675bf8 \
  --instance-type t3.micro \
  --security-group-ids $sg_id \
  --user-data file://./user-data \
  --query 'Instances[0].InstanceId' --output text)

# Wait for it to be running
aws ec2 wait instance-running --region us-east-2 --instance-ids $instance_id

# Get the public IP
set ip (aws ec2 describe-instances \
  --region us-east-2 \
  --instance-ids $instance_id \
  --query 'Reservations[0].Instances[0].PublicIpAddress' --output text)

echo $ip

Note that when we made this VM we did not give it a public key. The only way to access it is via a certificate it trusts!

Actually SSH to the VM!

Given the above, we can ssh in:

ssh arch@$ip

It should pop a browser which asks you to log in, which you should do. When everything authenticates you should be back in ssh, and be able to connect:

epithet-demo [!?] on  main ❯ ssh arch@$ip
       .
      / \
     /   \
    /^.   \     Arch Linux AMI (std)
   /  .-.  \    https://archlinux.org/
  /  (   ) _\
 / _.~   ~._^\
/.^         ^.\ TM
[arch@ip-172-31-46-139 ~]$

Yea!

If you look over at the agent there will be a bunch of debug output showing what it did.

If you log out (or open a new terminal) you can inspect the state of the epithet agent:

epithet inspect

Which will show you the ssh agent sockets it has running and the certs it has:

Broker State
============

Socket: /Users/brianm/.epithet/run/d6d98793bf4b428a/broker.sock
Agent Dir: /Users/brianm/.epithet/run/d6d98793bf4b428a/agent
Match Patterns: [*]

Agents (1)
-----------
  8fea92165cf18c9783b9b4e9b30ac50c559dd352
    Socket: /Users/brianm/.epithet/run/d6d98793bf4b428a/agent/8fea92165cf18c9783b9b4e9b30ac50c559dd352
    Expires: 2025-11-30T13:45:52-08:00 (valid, 2m17s)
    Certificate: SHA256:cadNJy5p6U7h/tfExl5M5GYZ/kJMpFoPEwf7dvFmGss

Certificates (1)
-----------------
  [0]
    Fingerprint: SHA256:cadNJy5p6U7h/tfExl5M5GYZ/kJMpFoPEwf7dvFmGss
    Identity: brianm@skife.org
    Principals: [arch]
    Valid: 2025-11-30T13:39:52-08:00 to 2025-11-30T13:45:52-08:00 (valid, 2m17s)
    Extensions:
      permit-agent-forwarding
      permit-pty
      permit-user-rc
    Policy (HostUsers):
      *: [arch]

The cert will expire in a few minutes, but the auth state should last as long as google doesn't want you to reauthenticate and you don't stop the agent. The auth state, certs, etc are all kept only in memory so killing the agent will wipe them out. No big deal, start the agent again and you can reauthenticate!

Run epithet as a daemon

If you installed via homebrew, it also added a homebrew service. You can enable the homebrew service via:

brew services start epithet

You can then stop it with stop instead of start, and so on. You need to restart it when you change the config, epithet agent does not pick up on config changes automagically.

Cleaning up config and playing around

Okay, so now you have a system, go play. The first thing I suggest doing is changing the match statement in ~/.epithet/config to match against just your VM and restarting the agent.

My config now looks like:

ca-url      https://ir6kilkap3.execute-api.us-east-1.amazonaws.com/
match       18.220.139.216
match       54.190.23.91
auth        epithet auth oidc --issuer https://accounts.google.com --client-id <abc123,etc>.apps.googleusercontent.com

Notice I have two match lines, that is because I spun up a second VM. The match line is used to short circuit what epithet tries to get a certificate for. In my actual day-to-day config it looks like:

ca-url      https://<REDACTED>/
match       *.home
match       *.barn
match       *.brianm.dev
auth        /opt/homebrew/bin/epithet auth oidc --issuer https://accounts.google.com --client-id <REDACTED>

Which relies on wildcard matching. Our fooling around VMs don't have useful names to match on, so there we go. Alternately, you could have the policy server reject them, which will also cause matches to fail, but that is a different (and not yet written) article.

To change the policy server config you can edit the config/policy.yaml file and redeploy it via make apply.

When you are done playing, if you want to tear down what we set up, you can run make destroy to tear down the resources tofu made. You'll need to stop your VMs yourself (aws --region us-east-2 ec2 terminate-instances --instance-ids $instance_id)-- tofu didn't make them for you, it doesn't know about them.

Debugging

I can hope everything went smoothly for you, but it may not have. If it didn't go smoothly, I have found Claude Code to be extremely good at helping debug terraform/aws stuff. In the repo with the the terraform resources there is a CLAUDE.md and MCP server specs (.mcp.json) for AWS and Terraform respectively. While I used Tofu, not Terraform, the MCP server knows both. If you don't have uv installed, install it (brew install uv) and the MCP servers will work. Fire up claude and ask it to help you debug your issues.

Triaging bugs

Ryan Bigg’s Blog — Sun, 30 Nov 2025 02:00:00 GMT

At Fat Zebra, one of my duties as a team lead is managing the workloads of those I work with and falling into that ambit is bug triaging. We have a dedicated support channel where people can tag all leads and then the responsible leads can triage those issues. All leads get tagged as it’s sometimes unclear who is responsible for an issue, and it helps with the “pinball effect” that can go on for tickets in their early stages.

The Importance of Side Projects

🦉 olshansky 🦁 — Sun, 30 Nov 2025 01:10:19 GMT

Side projects are one of those things I go back and forth on.

On one hand, I used to think that if you’re so passionate about a side project, why don’t you make it your fulltime job?

On the other hand, there are so many reasons to do them:

You can tinker without getting in anyone’s way
There’s no need to plan, prioritize or coordinate with others
It’s a form of “active recovery”
There’s no pressure to deliver results
It allows you to put yourself in a different mindspace and environment that can bring about new ideas
No matter how passioante you are about your work, you need to step away sometimes
???

I’ll periodically come back here and keep updating this list…

snake_case in Cargo sucks

River Writes - A MediaWiki Blog — Sat, 29 Nov 2025 21:11:42 GMT

Cargo will sometimes confusingly change your underscores to spaces if you use snake_case in your field names, so please don’t do that

Engineering

unsungNovelty — Sat, 29 Nov 2025 16:22:23 GMT

Underdog

unsungNovelty — Sat, 29 Nov 2025 16:14:03 GMT

Layers

unsungNovelty — Sat, 29 Nov 2025 16:13:57 GMT

Old School

unsungNovelty — Sat, 29 Nov 2025 16:00:15 GMT

Warmth

unsungNovelty — Sat, 29 Nov 2025 15:37:53 GMT

Connection Pooling: Fundamentals, Challenges and Trade-offs

Engineering At Scale — Sat, 29 Nov 2025 12:47:26 GMT

How to handle 10,000 concurrent requests without crashing your database

Everything the light touches

unsungNovelty — Sat, 29 Nov 2025 10:27:17 GMT

Experiment: Using Native macOS Apps to Install AI Workflows for Teammates

Zachary Proser — Sat, 29 Nov 2025 02:00:00 GMT

Why I built a native Swift installer instead of writing another setup guide

Rinku: CLI link previews

xenodium.com @alvaro — Sat, 29 Nov 2025 02:00:00 GMT

In my last Bending Emacs episode, I talked about overlays and used them to render link previews in an Emacs buffer.

While the overlays merely render an image, the actual link preview image is generated by rinku, a tiny command line utility I built recently.

Rinku leverages macOS APIs to do the actual heavy lifting, rendering/capturing a view off screen, and saving to disk. Similarly, it can fetch preview metadata, also saving the related thumbnail to disk. In both cases, rinku outputs to JSON.

By default, rinku fetches metadata for you.

rinku https://soundcloud.com/shehackedyou

Returns:

{
  "title": "she hacked you",
  "url": "https://soundcloud.com/shehackedyou",
  "image": "path/to/preview.png"
}

In this instance, the image looks a little something like this:

On the other hand, the --render flag generates a preview, very much like the ones you see in native macOS and iOS apps.

rinku --render https://soundcloud.com/shehackedyou

Returns:

{
  "image": "path/to/preview.png"
}

Similarly, the preview renders as follows:

Eshell superpowers

While overlays is one way to integrate rinku anywhere in Emacs, I had been meaning to look into what I can do for eshell in particular. Eshell is just another buffer, and while overlays could do the job, I wanted a shell-like experience. After all, I already knew we can echo images into an eshell buffer.

Before getting to rinku on eshell, there's a related hack I'd been meaning to get to for some time… While we're all likely familiar with the cat command, I remember being a little surprised to find that eshell offers an alternative cat elisp implementation. Surprised too? Go check it!

$ which cat
eshell/cat is a native-comp-function in ‘em-unix.el’.

Where am I going with this? Well, if eshell's cat command is an elisp implementation, we know its internals are up for grabs, so we can technically extend it to display images too. eshell/cat is just another function, so we can advice it to add image superpowers.

I was pleasantly surprised at how little code was needed. It basically scans for image arguments to handle within advice and otherwise delegates to eshell's original cat implementation.

(defun adviced:eshell/cat (orig-fun &rest args)
  "Like `eshell/cat' but with image support."
  (if (seq-every-p (lambda (arg)
                     (and (stringp arg)
                          (file-exists-p arg)
                          (image-supported-file-p arg)))
                   args)
      (with-temp-buffer
        (insert "\n")
        (dolist (path args)
          (let ((spec (create-image
                       (expand-file-name path)
                       (image-type-from-file-name path)
                       nil :max-width 350
                       :conversion (lambda (data) data))))
            (image-flush spec)
            (insert-image spec))
          (insert "\n"))
        (insert "\n")
        (buffer-string))
    (apply orig-fun args)))

(advice-add #'eshell/cat :around #'adviced:eshell/cat)

And with that, we can see our freshly powered-up cat command in action:

By now, you may wonder why the cat detour when the post was really about rinku? You see, this is Emacs, and everything compounds! We can now leverage our revamped cat command to give similar eshell superpowers to rinku, by merely adding an eshell/rinku function.

As we now know, rinku outputs things to JSON, so we can use json-read-from-string to parse the process output and subsequently feed the image path to eshell/cat. rinku can also output link titles, so we can show that too whenever possible.

(defun eshell/rinku (&rest args)
  "Fetch link preview with rinku and display image inline.

Usage: rinku https://soundcloud.com/shehackedyou
       rinku --render https://soundcloud.com/shehackedyou"
  (unless args
    (error "rinku: no arguments provided"))
  (let* ((output (with-temp-buffer
                   (apply #'call-process "rinku" nil t nil args)
                   (buffer-string)))
         (metadata (condition-case nil
                       (json-read-from-string output)
                     (error nil))))
    (if metadata
        (concat
         (if (map-elt metadata 'image)
             (eshell/cat (map-elt metadata 'image))
           "\n")
         (when (map-elt metadata 'title)
           (concat (map-elt metadata 'title)
                   "\n\n")))
      output)))

With that, we can see the lot in action:

While non-Emacs users are often puzzled by how frequently we bring user flows and integrations on to our beloved editor, once you learn a little elisp, you start realising how relatively easily things can integrate with one another and pretty much everything is up for grabs.

Make it all sustainable

Reckon rinku and these tips will be useful to you? Enjoying this blog or my projects? I am an 👉 indie dev 👈. Help make it sustainable by ✨sponsoring✨

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

[RIDGELINE] No Phones in The Ten-don Shop

Craig Mod — Writer + Photographer — Sat, 29 Nov 2025 02:00:00 GMT

Ridgeline subscribers —

(Originally published in Japanese in Esquire Japan, October 2025)

Some twenty-three years ago in Tokyo, I used to eat at a funny little tendon shop called Imoya. I was a student at Waseda University back then, and this place was a campus staple. Tendon, when done well, can be divine, and Imoya was divine through and through.

The shop was run by the crankiest husband and wife you ever met. The whole place was just seven or eight counter seats around an open kitchen. The husband apparently lived in the attic of the shop. A little hatch in the ceiling opened and down fell a ladder. Up he climbed like a spider. (So went the college kid lore.) The wife lived down the road a few miles away in Iidabashi and walked back and forth each day. But together they had decided that their community role — as a cantankerous duo — was to provide as many delicious bowls of tendon to as many students for as cheaply as they could. I forget the precise cost, but it was probably about ¥500. Boy was it voluminous. And I think a fat ōmori heaping was free. But they had rules, and you had better obey those rules.

Extraordinary Claims

ho.dges.online — Sat, 29 Nov 2025 02:00:00 GMT

“Extraordinary claims require extraordinary evidence.”

PyTorch Fundamentals - Week 5

Playground — Sat, 29 Nov 2025 02:00:00 GMT

Brushing up on my PyTorch skills every week. Starting from scratch. Not in a hurry. The goal is to follow along TorchLeet and go up to karpathy/nanoGPT or karpathy/nanochat. Previously,

LFS148: Getting Started with OpenTelemetry

Domenico Luciani — Sat, 29 Nov 2025 01:00:00 GMT

Want to dive-in into OpenTelemetry? This course is for you

Langjam Gamejam: Build a programming language and then use it to make a game in 7 days

Austin Z. Henley's Blog — Fri, 28 Nov 2025 22:00:01 GMT

https://austinhenley.com/blog/langjamgamejam.html

Claude the frontend dev

Martijn Arts — Fri, 28 Nov 2025 18:40:14 GMT

Working on Holt Kit, I need to write a lot of Leptos components. A lot.

Lots of components still to be done...

Holt Kit is intended to be an overly complete collection of elements, which need to be maintainable and have a consistent level of quality and implementation style. So

The most joyous portrait of love I’ve ever heard

Superb Owl — Fri, 28 Nov 2025 18:16:12 GMT

The story of the album Tête-à-Tête, by Annea Lockwood and Ruth Anderson

Thoughts on taxes

Ananth's Reflections — Fri, 28 Nov 2025 17:03:30 GMT

Government needs revenue for various things it needs to do - military, infrastructure, providing services, for providing some social security and to pay federal administration among other things.

Using Claude Code to Build gocat

Greg Herlein — Fri, 28 Nov 2025 10:00:01 GMT

In my previous post about Claude Code, I talked about using VS Code devcontainers to safely run Claude in “dangerous mode.” That was great for a typical software project. But what about something harder? What about porting a complex hardware-interfacing library from Python to Go, where you need to deeply understand USB protocols, radio registers, and firmware internals?

That’s exactly what I did with gocat – a Go library for controlling the YardStick One sub-GHz RF transceiver. And Claude Code was instrumental in making it happen.

Best Voice-to-Text for Developers in 2025: My Tested Recommendations

Zachary Proser — Fri, 28 Nov 2025 02:00:00 GMT

Tested recommendations for the best voice-to-text tools for developers. From coding with WisprFlow at 179 WPM to meeting notes with Granola. Real experience, not marketing.

Granola vs Otter.ai: I Tested Both for Months

Zachary Proser — Fri, 28 Nov 2025 02:00:00 GMT

I used Granola and Otter.ai side by side for months. One requires a bot, one doesn't. Here's which one I kept and why.

WisprFlow vs Whisper (OpenAI): Which Voice-to-Text is Better for Developers?

Zachary Proser — Fri, 28 Nov 2025 02:00:00 GMT

Detailed comparison of WisprFlow vs OpenAI Whisper for developers. Compare accuracy, speed, integration, pricing, and real-world performance for voice-to-text coding.

[RODEN] Blank Spaces, Radicalized Offlineness, Curious Protagonists

Craig Mod — Writer + Photographer — Fri, 28 Nov 2025 02:00:00 GMT

Roden Readers —

Ahh, it’s nice. The outside. The outside is nice. Finally, very nice. The best season in Japan. The leaves, they change. Out yonder, Mt. Fuji performs foojalicousness on the horizon as I type these very words. Being a bit coy, hiding, peeking, hiding once again. The usual Fooj, all snow capped and sweet.

’Tis the season to Buy Things, apparently. So says every website in the world. Black Friday, now also a Japan Thing. Our faces are being smashed by sales. If you’re going to buy anything, I say buy books:

Your AI Agent Config is Technical Debt You Haven't Acknowledged Yet

Prasham H Trivedi — Fri, 28 Nov 2025 02:00:00 GMT

We’ve evolved from slash commands to MCP servers to skills, but our configs haven’t. That prompt from the Claude 3.7 era? It’s still running. That’s not legacy-it’s debt.

Epithet, v2, Briefly - Part 1

Brian's Waste of Time — Fri, 28 Nov 2025 02:00:00 GMT

I last talked about epithet two years ago, in 2023, when I started kicking around ideas to make it general purpose. I'm pleased with how it's turned out, so I want to start talking about some of the design decisions. I dare not document it yet, for fear someone may use it, but that's probably coming.

Even though it never had a proper 1.0, I am calling this v2 in my head as it is not at all compatible with the previous iteration, and is so much better. The big pieces are the same shape: an Agent, a CA, and a Policy service:

Agent

The agent handles authenticating you, obtaining certificates, and deciding which certificate to use for a given connection. It uses a small policy protocol to match certificates against connections based on target host and remote username. Authentication is handled by a plugin system, so you can have arbitrary authenticators. There's a built-in OIDC authenticator, and I imagine I'll add SAML at some point.

Policy Service

The Policy Service is the brains of the system. It receives authentication and connection information and decides (1) whether to issue a cert, (2) which principals to put on the cert, (3) the cert parameters (expiration, extensions, etc), and (4) a matching policy telling the agent which connections this cert can be used for.

CA

The CA has access to the CA private key, so I want it to be as simple as possible. As such it delegates decision making about certificates to the policy service and merely issues certs as instructed.

So what's changed and why?

That looks pretty similar to two years ago, but there are a few key changes I'll dive into over a few posts. Today, the big reasons for the changes:

I want to be able to issue a certificate which allows someone (or some process) to ssh into a specific host as a specific user only, rather than a more wide-open certificate with all of the user's principals. Imagine, if you will, a piece of deployment automation. We want it to be able to ssh as deploy@prod-*.example.com for the next ten minutes. Allowing this should be triggered by a workflow -- either automatically by inspecting if it should be deploying right now, or via a human workflow such as a response in Slack, and so on.
I don't want to bake in assumptions about how identities, principals, and hosts map to each other. The unix-group style set of principals from the previous version is reasonable for many use cases, but not all. It's overkill for simple cases (my personal stuff) and not powerful enough for the hard cases (see above).
I want to coexist better with non-epithet ssh scenarios. Previously users had to carefully craft Match blocks in their ssh config to only use epithet when appropriate. Worse, if the CA or policy server was down, users would need to edit their ssh config to use a fallback. The last thing you want to do in a SEV is edit ssh config.

AI has no taste

Monroe Clinton — Fri, 28 Nov 2025 02:00:00 GMT

I find AI useful as a better search engine and little past that. The reason being that I have a taste for what I like and what I don’t like. AI is not able to digest that taste because it does not operate at the individual human level. I have a feeling that people are part of an unquantifiable world, and it is unfathomable that a statistical entity will ever “get” the unquantifiable.

Working Faster with Git Worktrees and AI-Based Multi-Workflow Development

Krystian Safjan's Blog — Fri, 28 Nov 2025 01:00:00 GMT

A practical, hands-on guide to turning a single codebase into a multi-workflow environment using Git worktrees, VS Code, and AI coding assistants. The tutorial shows how to isolate experiments, compare results, and speed up refactoring work with agents and Copilot.

Using Git Worktrees as Clean Rooms for AI-Assisted Coding

Krystian Safjan's Blog — Fri, 28 Nov 2025 01:00:00 GMT

Learn how Git worktrees create isolated environments for AI-assisted coding, allowing you to keep your main development line clean while experimenting with AI suggestions in dedicated branches.

Happy Thanksgiving

Zappable — Fri, 28 Nov 2025 00:36:42 GMT

Gratitude for existence and awareness

RISC-V OrangePi RV2 Linux SBC

Fabrice Aneche — Thu, 27 Nov 2025 22:00:00 GMT

In April 2025, I’ve ordered two OrangePi RV2, as soon as they announced Ubuntu 22.04 support, they are running 24x7 since then. The Ky X1 CPU is a RISC-V (RISC-V is open and royalty-free), 8 Core, the architecture is riscv64, (so not arm64/aarch64). Linux risc5 6.6.63-ky #1.0.0 SMP PREEMPT Wed Mar 12 09:04:00 CST 2025 riscv64 riscv64 riscv64 GNU/Linux It has two M.2 sockets, I have it installed with a 256GB NVMe drive, two Gigabits Ethernet ports, particularly useful for a direct interconnect in a cluster.

Verso

Brian Sunter — Thu, 27 Nov 2025 10:37:18 GMT

A high-performance vector database for Bun, Node.js, and the browser. HNSW indexing, Int8 quantization, and pluggable storage backends.

The Quiet Earth

Marc Stuff — Thu, 27 Nov 2025 02:42:10 GMT

Above: A still image from “The Quiet Earth” (1985)

Lately it’s been dark here. A dark time of year, a dark political era…hell, I am afraid I could just go on and on about darkness!

Everybody’s got their ways of coping with this, whether that’s done by the automatic / instinctive side of the personality, or in a more conscious way.

On the conscious side, one thing that reliably helps me out in dark times is engaging with the personal hobbies and interests that seem to call out to me for attention.

Personal Interests are Kinda Lit

This topic by itself has become a huge interest of mine over the years. I like to study the way our personal interests can guide us through life in a mysteriously helpful way. They often do this through symbolic language.

Our personal interests tend to bring light into the dark corners of our lives, if given proper attention. And even if they don’t seem directly related to “resolving issues in global politics” or “dealing with that one coworker”, they often do relate to those things, somehow. I’m often surprised to find just how direct the connection actually is!

People usually talk about “engagement with personal interests” as something that disconnects us from the broader world, for good or bad…but my experiences also seem to point out that this is quite the opposite in a lot of ways.

I believe there is a strong, symbiotic relationship between those two realms: Out there, and in here.

Getting Gripped (by an Interest)

Related, one of the techniques that’s seized me lately works a lot like this:

Get excited about something. Get sucked into it! (Wow, this movie, or wow, this book! Or hobby, or whatever it is…)
Identify that new world and its energy, as a specific type of view on things, or a specific approach to things. More on this below.
Live through that world—think about your life using the tools and viewpoints from that world.

Some of this process comes from my training in Jungian-oriented topics, and some from various corners of personality theory.

But, this past weekend, one of those excitements snuck up and gripped me something good. And I wanted to share how that worked out, mostly to review, but also in case it can help somebody else.

Roll Tape

This time, it was The Quiet Earth, an ’80s movie that grabbed me once again, and sucked me in. It’s definitely one of my favorite films.

Independent, plucky, unique, and deep, it’s also everything that doesn’t describe me on the average lazy Sunday.

In the movie, the main character wakes up to find that he’s the only person left alive. On the entire planet. This is the result of a scientific experiment in which he took part: Project Flashlight.

It soon becomes clear that this person bears some responsibility for ending up completely isolated, maybe even for killing almost everyone on the planet.

There is a tremendous moral burden on this character, but he’s also just barely realizing that he’s part of a broader, selfish, shortsighted, killing system…and now…

…what to do about it?

This Kind of Topic Helps Me Out Sometimes

Why this movie? Why this approach?

Personally, I didn’t pick this interest. But if I had to guess why my subconscious mind found it interesting: It often really helps me to look at the world from this kind of viewpoint: “Oh no, what’s happened? Things are so weird and disconcerting lately. And what can I do about it?”

Solving novel problems is one way to look at this, and that is one of the skills I have worked hard on in my professional practice in recent years. So, that connection makes sense to me.

Here are some more specific examples why this helps:

First, I notice that I get more energy if I decide that stuff is really weird lately. lol. It’s more fun to look at the world this way, for me. It opens up the imagination and anyway, my mind has always been naturally attuned to single out “something weird that’s going on.”

Second: “Maybe I had a part in it, but let’s find out.” I’m a character-motivated person. I like to think about my role in things. There’s some personal-discovery and maybe also a personal redemption arc here, as is usually true for all of us. One of us, is all of us.

Within each of us is every philosophical perspective, doing some sort of battle against another perspective from time to time. Is it better to be Simple with this project, or a bit more fancy? Is it better to be a pragmatic person, or more sensitive to broader issues? Looking back, or looking forward? Focused on the now, or lost in thought?

When one of those perspectives wins, another perfectly good perspective tends to lose. And that can be really, really unfortunate, because they’re also a full palette of helpful tools and techniques.

Third, I feel kind of alone in dealing with the problems at hand…but that’s also a strength. I mean, there’s always some clear need to link together, if possible, to solve huge problems in society. But there’s also a separate strength in looking at problems that only seem to affect us.

(Eventually, maybe we can even publish the problems in a way that helps us link up with others, so whether this “I’m alone in dealing with this” is a good thing is also an open, process-related question and a matter to sort out over time.)

And finally, I get the idea that I can probably make some sense of the problem at hand, but I need to watch closely and make observations. To activate some sensitivity, this powerful tool we can use to analyze and tackle problems.

How it worked out

Translating a personal interest, or a fantasy world, into personal perspectives and tools seems to be a really helpful practice so far.

And I have to say I love the advantages of the scientific angle:

Patience is rewarded. This is not an action movie. Think through the problem well.
Unique perspectives are welcome. Again, we need so many different tools in life. You never know what can help.
We embrace the fact that dark things can happen. Embracing darkness means that we don’t try to only look on the bright side of everything, because sometimes this is just the same as blinding ourselves. With closed-off perspectives, we close off access to many important problem-solving tools. And darkness is usually just “depth in disguise.”

In the event, I took up my notebook and drew out a pleasant, organized, scientific grid layout.

Then at the top of the paper, I wrote: PROJECT FLASHLIGHT LOG (a reference to the movie), merging the movie theme with my own inner world.

I worked through general descriptions: Something’s off. What will I try now? What do I need to do?

This soon included a little to-do list, on the side. “Drink some water.” Never leave out the mundane stuff!

But also: “Take crucial measurements.”

For me, this is a thing I do—I measure my personal energy, how I’m feeling. It’s an activity I do while I’m journaling.

What Does It Mean?

In the end…I moved ahead in that particular movie-mindset, as the scientist of who-knows-what-is-going-on.

I decided to do some very specific things next, as experiments, and I did those things, or scheduled them.

And on a Sunday, no less! Hah.

I don’t want to overstate this, but it really just helps to move ahead. For most of us, that’s most of what we need on any given day! The feeling of forging ahead in life doesn’t really have to be that fancy.

And the tools we use to move ahead may also seem fancy, but it’s important to realize: Even if they just help us keep going, that’s usually plenty of help, and who’s to say if that’s fancy, if it just works!

Still, everything’s dark, and I hate it, ugh

These are, in many ways, dark times. For all of us.

Tracking that, and managing its effect on our lives, can be very hard. Attention to global issues can easily cascade into dark fallout in our personal lives. This is generally true, the less-conscious we are of a need to find our own way of solving important problems in our lives, even the dark ones.

Circumstances seem dire, and the tools available to us even seem dire sometimes. Even scrolling on a social media site these days feels like flirting with dangerous mental conditions, inviting some new level of anxiety, or depression, or obsession with some disquieting thing in a disconcerting way.

So, in this case, recognizing and seizing a motivating personal interest, or personal fantasy, if I can call it that, is a very clear, straightforward win.

Every global problem is also a personal problem, and movement on either end of that chain is helpful.

(And maybe for another time: What the hell has gone wrong with social media, anyway?)

That’s it for now everybody! May you also find some weird thing in your life that’s really interesting and ideally, helpful. :-) —Marc

Video: The Midnight – The Equaliser (Not Alone)

Benchmarking checksum tools

Heitor's log — Thu, 27 Nov 2025 02:00:00 GMT

There are plenty of CLI tools to calculate the checksum of files. But, which one is the fastest?

Bending Emacs - Episode 6: Overlays

xenodium.com @alvaro — Thu, 27 Nov 2025 02:00:00 GMT

The Bending Emacs series continues with a new a new episode.

Bending Emacs Episode 6: Overlays

Today we had a quick intro to overlays. Here's the snippet I used for adding snippets:

(save-excursion
  (goto-char (point-min))
  (when (search-forward "Hello World" nil t)
    (let* ((start (match-beginning 0))
           (end (match-end 0))
           (ov (make-overlay start end)))
      (overlay-put ov 'face '(:box (:line-width 1 :color "yellow")))
      ;; (overlay-put ov 'face 'underline)
      ;; (overlay-put ov 'face 'highlight)
      ;; (overlay-put ov 'before-string "🔥 ")
      ;; (overlay-put ov 'after-string  " 🚀")
      ;; (overlay-put ov 'display  "Howdy Planet")
      ;; (overlay-put ov 'invisible t)
      ;; (overlay-put ov 'help-echo "Yay overlay!")
      ;; (overlay-put ov 'mouse-face 'success)
      (overlay-put ov 'category 'overlays)
      (overlay-put ov 'evaporate t)
      ov)))

Similarly, this is what we used for removing the overlay.

(remove-overlays (point-min) (point-max)
                 'category 'overlays)

Of the experiments, you can find:

Redaction snippet at the related blog post.
Dired media metadata at Ready Player's ready-player-dired.el.
Link previews: While I don't have elisp to share for link previews just yet, I did release a tiny thumbnail utility named rinku ;)

Hope you enjoyed the video!

Want more videos?

Liked the video? Please let me know. Got feedback? Leave me some comments.

Please go like my video, share with others, and subscribe to my channel.

If there's enough interest, I'll continue making more videos!

Make it all sustainable

Enjoying this content or my projects? I am an indie dev. Help make it sustainable by ✨sponsoring✨

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

The Input Stack on Linux An End-To-End Architecture Overview

Venam's Blog — Patrick Louis (Lebanon) — Thu, 27 Nov 2025 00:00:00 GMT

Let's explore and deobfuscate the input stack on Linux. Our aim is to understand its components and what each does. Input handling can be divided into two parts, separated by a common layer. We’ll try to make sense of all this, one thing at a time, with a logical and coherent approach.

A Vibe Coded SaaS Killed My Team

Wed, 26 Nov 2025 18:00:00 GMT

We lost the capitalism game and they're trying to get a second wind through a broken vibe-coded SaaS platform.

Why Are You Productive For "Only" 5-6 Hours Each Day?

Ashley Janssen Consulting — Wed, 26 Nov 2025 17:53:52 GMT

Almost no one is productive for 8 hours a day straight! Learn why and how to think about your daily productivity differently.

Poor Man's Merge Conflict Resolver

🦉 olshansky 🦁 — Wed, 26 Nov 2025 17:40:19 GMT

A claude tool to help resolve merge conflicts

My session on MCP servers at .NET Conference Italia 2025

Nicola Iarocci — Wed, 26 Nov 2025 17:24:38 GMT

I presented a session at the .NET Conference Italia 2025 in Milan a couple of weeks ago. The title was “Integrating our applications with LLMs and AI via MCP Servers”. It was well received; there were good questions throughout the talk and in the hall afterward. Surprisingly, live coding and demos went relatively smoothly.

The fine guys at ASP Italia just published the video in case someone is interested.

Yeah, it is in Italian. I got a transcript from MacWhisper and then asked Claude to translate and clean it up. It did a pretty good job, so let me know if there’s any interest in an English transcript; I might post it here.

Money and Intelligence

🦉 olshansky 🦁 — Wed, 26 Nov 2025 16:32:08 GMT

A thought on money and intelligence.

Time

Nicola Iarocci — Wed, 26 Nov 2025 09:31:56 GMT

If you want to understand time — which is how you come to befriend life — turn to stone. Climb a mountain and listen to the conversation between eons encoded in each stripe of rock. Walk a beach and comb your fingers through the golden dust that was once a mountain. Pick up a perfect oval pebble and feel its mute assurance that time can grind down even the heaviest boulder, and smooth even the sharpest edge.

Own A Graph

Stay SaaSy — Wed, 26 Nov 2025 08:59:22 GMT

Show me the graph!

Dissecting The Halo 5 Spartan Rank Manifest

Den Delimarsky — Wed, 26 Nov 2025 02:00:00 GMT

Did you know that Halo 5 had an entire API endpoint that defined the Spartan Rank progression? You do now - here is what it had inside.

Festive offers for books on Python, Linux, Regular Expressions, Vim and more!

learnbyexample — Wed, 26 Nov 2025 02:00:00 GMT

Hello!

Here are some awesome deals for programming books and courses during the 2025 festive season.

My ebooks🔗

Festive offers for my ebooks till 30-November-2025:

All 13 Books Bundle — $16 (normal price $36), learn Regular Expressions, Linux CLI tools, Python, Vim and more!
Understanding Python re(gex)? — FREE (normal price $10)

Other deals🔗

Python related deals
The Pragmatic Bookshelf — 50% off
Deals on Django and Git books/software
Huge list of awesome deals — tools, productivity, books, courses, etc
blackfridaydeals.dev — Hottest Black Friday Deals for Developers

Happy learning :)

Is psql's scripting language Turing complete? Or: fibonacci in psql

Notes on software development — Wed, 26 Nov 2025 02:00:00 GMT

This is an external post of mine. Click here if you are not redirected.

Gullane Golf Club

Wigs on the Green — Tue, 25 Nov 2025 17:03:10 GMT

Three courses on a hill

On Idempotency Keys

Gunnar Morling — Tue, 25 Nov 2025 14:10:00 GMT

Table of Contents

UUIDs
Monotonically Increasing Sequences
Deriving Idempotency Keys From the Transaction Log
Discussion

In distributed systems, there’s a common understanding that it is not possible to guarantee exactly-once delivery of messages. What is possible though is exactly-once processing. By adding a unique idempotency key to each message, you can enable consumers to recognize and ignore duplicate messages, i.e. messages which they have received and successfully processed before.

Train Dreams

Nicola Iarocci — Tue, 25 Nov 2025 11:09:37 GMT

With all the medium-to-very-low-quality productions we’ve been accustomed to from Netflix, it was a pleasant surprise and a relief to watch Train Dreams last night.

I’ll quote the most recent review on IMDb:

Robert’s life is gently lived and not without profound tragedy. The film evokes our own memories, little joys and sadnesses, discoveries, losses, and hopes, bringing grace to our self-reflection. The film is heartbreakingly beautiful. Acting, editing, and direction are just right.

Lessons from two failed promotions... and what changed after ZIRP

João Alves — Tue, 25 Nov 2025 11:01:24 GMT

Every time we talk about promotions and career paths, we listen a lot about how to get there. Today, I want to tell the story of how I failed to get the role... twice!

For context: I joined Adevinta as Engineering Manager of the Runtime team in late 2020. We were part of an internal Platform-as-a-Service (PaaS) offering. We provided SCHIP, a Kubernetes container runtime.

Fast forward a few years. We onboarded every marketplace of the group. We increased traffic and handled more requests per second in our clusters. We improved how we supported users. We shipped new features. And we helped Adevinta migrate to the Public Cloud on Amazon Web Services (AWS). I was proud of the team. I was proud of the culture we built. I had great feedback from my managers. And I felt I was ready for the next step.

So, when Renaud, the VP of Cloud and Infrastructure, opened a “Head of Cloud Platform” position, I thought: there we go! The process consisted of two 1:1 interviews: one with the VP himself and another with the Product & Tech’s Human Resources Business Partner (HRBP).

Looking back, there were three things I missed:

I talked about my impact, but not enough about how I already operated at level n+1. My pitch was strong on management, leadership, and Cloud knowledge. But weak on stories that proved I was thinking like a Head. Although my managers delegated “n+1” work to me and I had some sense of what the job entailed, it led to a “strong potential, but not yet there” rating.
The second one is perhaps obvious, but I’ll say it out loud anyway: the higher you climb the ladder, the stronger the candidates competing against you will be. Most hiring managers will put their chips on experience vs potential. At the end of the day, the whole organization will respond, and it’s not always the best time to place risky bets.
I didn’t invest early enough in visibility. Inside my team, I had a strong reputation. Outside my team, fewer people had seen me operate. At senior levels, trust does not build in a one-hour interview. You need a signal long before that. I should have connected more, shared more, collaborated more across domains. By the time I realized it, it was too late. Some people think this is politics. And it is. But it’s also reality. If an interviewer has one hour with you and must evaluate several strong candidates, who do you think will be top of mind?

Image generated with Gemini-3/NanoBanana

Promotions in a post-ZIRP world

During the Zero Interest Rate Period (ZIRP) years, promotions were easier to obtain. Companies were growing fast, and teams expanded, growing headcount every year. New products launched. New layers of management appeared. Many careers moved forward because the business kept moving forward.

That time is now over. Interest rates rose, and growth slowed. Engineering organizations became flatter. We can see companies like Amazon trimming manager-heavy structures.

To sum up: fewer roles. Higher expectations. Tougher competition. If you want to grow in this new environment, you need to adapt your strategy. Here are the key shifts to keep in mind:

Being great at your job is not enough. You need to demonstrate that you already operate at the next level, and make that evidence easy to see. Prepare clear stories with the STAR method that show judgment, cross-team impact, and decisions that look like level n+1 work. Ask your manager for delegation (e.g., volunteer for initiatives that stretch your scope). Build the proof before you need it. And remember: in a slow-growth world, leaders favor experience over potential. You must close that gap by preparing intensely. Some people think the promotion loop is just a waste of time, like an interview. It turns out it is an interview! Bring a crisp 90-day plan. Show how you think. Show how you would lead. Do not rely on “I did a great job.” Rely on proof that you can operate bigger.
Visibility is a core skill. Treat it as part of the job. Trust at senior levels does not form in a one-hour interview. It forms because people have seen you operate, reason, and collaborate. Make visibility intentional by sharing learnings or writing decision documents. Help teams outside your area. Ask thoughtful questions in cross-org forums. If you walk into a promotion loop with zero pre-existing signal, you will lose to someone who built it over months.
Leverage matters more than headcount. In the ZIRP era, promotions often came with growing teams. That world changed. Now companies reward leverage:
- the systems you fix
- the cross-team problems you unblock
- the decisions you improve
- the clarity you bring
- the cultural habits you reinforce

Span of control matters less. Measurable impact across boundaries matters more. Start asking: “What work creates the biggest lift for the organization, not just my team?” Then run toward that work.

Before you chase your next promotion

The career ladders for Engineering Managers didn’t disappear. They just got steeper. With the proper preparation, the right stories, and the right visibility, you can still climb them.

I learned these lessons through some painful misses, so you don’t have to. If you want to talk about your own path or need help preparing for a step up, my inbox is always open.

I Am Not Yours

Nicola Iarocci — Tue, 25 Nov 2025 09:18:56 GMT

I was walking early this morning, as usual, when I came across an unusual advertising sign. It was in Spanish, text only, red background and black typography. I don’t comprehend Spanish well enough to read it, so I photographed it and sent it to Serena, who promptly replied with the translation.

Embarrassingly, just yesterday, I got a severe reprimand from Serena because I did not know or remember what day it was today. When I got back, I traced the source and found that the sign is actually available in several languages.

Review: Airpods Pro 2 with Android

Nithin Bekal — Tue, 25 Nov 2025 02:00:00 GMT

I’ve been using the Airpods Pro 2 with an Android phone for the past few months. Recently, I came across the Librepods project, which aims to unlock Apple exclusive features available for Android users. This requires rooting the phone, so I’m too keen on installing it, but I was curious about what I’m missing, which prompted this post.

One Year Of Model Context Protocol Through A Core Maintainer Lens

Den Delimarsky — Tue, 25 Nov 2025 02:00:00 GMT

Model Context Protocol is a year old today. Along with its birthday, we’re also celebrating the release of the 2025-11-25 spec version.

Building AI Agents for DevOps: From CI/CD Automation to Autonomous Deployments

Tue, 25 Nov 2025 02:00:00 GMT

In my previous post, I showed you how to build a CI/CD pipeline runner from scratch in Python. We built something powerful: a system that could orchestrate jobs, manage dependencies, and pass artifacts between stages. It was the muscles of your deployment workflow.

But here’s the problem: that pipeline runner can only do exactly what you tell it to do.

It’s 2 AM. Your deployment pipeline fails. The error message is cryptic: Error: Connection refused on port 5432. Your traditional CI/CD pipeline stops dead. It sends an alert. You wake up, check the logs, realize the database connection pool was exhausted, restart the service, and go back to bed frustrated.

What if your pipeline could investigate the failure itself?

What if, instead of just stopping and alerting you, it could:

Analyze the error logs
Check recent code changes
Search for similar issues in your repository
Identify that this same error happened two weeks ago when someone forgot to increase the connection pool
Post a detailed root cause analysis to Slack with a suggested fix

That’s not science fiction. That’s what AI agents can do for your DevOps workflows.

Over the past 2 years working independently as a DevOps consultant, I’ve seen the same patterns at every client: pipeline failures that need investigation, deployment decisions that require context, and incidents that demand rapid root cause analysis. These aren’t problems that need faster execution. They need reasoning.

That’s when I realized: the CI/CD runner we built is powerful, but it’s missing a brain. So I decided to add one.

Traditional Automation vs. AI Agents

Here’s the fundamental difference:

Traditional CI/CD Pipeline	AI Agent
Executes predefined steps in order	Reasons about what steps to take
Fails when encountering unexpected situations	Investigates and adapts to new situations
Requires humans to make decisions	Makes informed decisions autonomously
Uses fixed if-then-else logic	Uses context-aware reasoning
Needs explicit error handling for every case	Generalizes from patterns and past experience

Your traditional pipeline is like a factory assembly line: efficient and reliable for known workflows, but completely stuck when something unexpected happens.

An AI agent is like a DevOps engineer who can think, investigate, and make decisions based on the full context of your system.

What We’re Building

In this post, I’m going to show you how to build a Pipeline Health Monitor Agent: an AI system that watches your GitHub Actions workflows and autonomously investigates failures.

Here’s what our agent will do:

Monitor: Watch for GitHub Actions workflow failures via webhooks
Investigate: Automatically fetch logs, check recent commits, and analyze error patterns
Reason: Use an LLM (like GPT-4 or Claude) to understand what went wrong
Report: Post detailed findings to Slack with actionable recommendations
Learn: Remember similar issues and apply learned patterns

And we’ll do all of this securely. Research shows that 48% of AI-generated code contains vulnerabilities, and I’m going to show you exactly how to validate every action your agent takes.

What You’ll Learn

By the end of this post, you’ll be able to:

Understand how AI agents differ from traditional automation and when to use each
Build a working DevOps AI agent using LangChain and LangGraph
Integrate the agent with your existing GitHub Actions workflows
Implement security validation layers to prevent AI-generated vulnerabilities

We’ll build this progressively: starting with the core agent, adding GitHub Actions integration, and then hardening it with security layers. Every code example will be complete and runnable.

The core philosophy: AI agents augment your pipeline, they don’t replace it. You’ll still have your traditional CI/CD workflows. The agent just makes them smarter.

Let’s start by understanding what AI agents actually are and how they work.

Understanding AI Agents: The 4 Core Components

Before we start coding, you need to understand what makes an AI agent fundamentally different from a script or a traditional automation workflow.

A traditional pipeline is a sequence of commands. An AI agent is a reasoning loop.

The Agent Loop

Every AI agent operates in a continuous cycle:

┌─────────────────────────────────────────────────────┐
│                                                     │
│  Observe → Reason → Plan → Act → Observe (repeat)   │
│                                                     │
└─────────────────────────────────────────────────────┘

Here’s what happens when your GitHub Actions workflow fails:

Observe: Agent receives webhook notification about pipeline failure
Reason: LLM analyzes the error message and context
Plan: Agent decides which tools to use (check logs, git history, search issues)
Act: Agent executes those tools and gathers information
Observe: Agent reviews tool outputs and repeats the cycle until it has an answer

This is completely different from your CI/CD runner, which executes steps linearly and stops when something fails.

The 4 Core Components

Every AI agent is built from these four pieces:

1. The LLM (Brain)

The Large Language Model is the decision-making engine. It takes in context (pipeline logs, error messages, git history) and decides what to do next.

Think of it as the “thinking” part. When your pipeline fails with a database connection error, the LLM reasons: “This could be a configuration issue, a networking problem, or resource exhaustion. I should check recent config changes first, then network logs, then resource usage.”

Common choices: GPT-4, Claude 3.5 Sonnet, GPT-3.5 (cheaper for simple tasks)

2. Tools (Hands)

Tools are functions the agent can call to interact with the world. For DevOps, these might be:

get_github_logs(workflow_id) - Fetch pipeline logs
analyze_recent_commits(repo, hours) - Check recent code changes
search_similar_issues(error_message) - Find related GitHub issues
get_docker_status(container_id) - Check container health
query_prometheus(metric, timerange) - Get monitoring data

The LLM decides which tools to call and when. You just define what each tool does.

3. Memory

Agents need two types of memory:

Short-term memory (conversation history): The current investigation. “I checked the logs and found a connection error. Then I checked recent commits and found a database config change.”

Long-term memory (learned patterns): Historical knowledge. “The last three times we saw Connection refused on port 5432, it was because the connection pool size was too small.”

For our pipeline monitor, we’ll start with short-term memory. Long-term memory requires a vector database (we’ll save that for a future post).

4. Prompts (Instructions)

The prompt is how you tell the agent what its job is and how to behave. A good DevOps agent prompt includes:

Role definition: “You are a DevOps AI agent that investigates pipeline failures.”
Context: “The system runs on Kubernetes in AWS. Database is PostgreSQL. Cache is Redis.”
Constraints: “Never execute destructive commands. Always explain your reasoning.”
Output format: “Provide a root cause analysis with suggested fixes.”

Prompt engineering is critical. A vague prompt like “debug the issue” will give you vague results. A specific prompt with context will give you actionable insights.

How It All Works Together

Here’s a concrete example of the agent loop in action:

Pipeline failure detected
    ↓
Agent observes: "Workflow #1234 failed with exit code 1"
    ↓
LLM reasons: "Exit code 1 is generic. I need more information."
    ↓
Agent plans: "Call get_github_logs() to see the actual error"
    ↓
Agent acts: Fetches logs, finds "psycopg2.OperationalError: could not connect to server"
    ↓
LLM reasons: "Database connection failure. Could be config, network, or resources."
    ↓
Agent plans: "Check recent commits for database config changes"
    ↓
Agent acts: Calls analyze_recent_commits(), finds commit changing DATABASE_URL
    ↓
LLM reasons: "Root cause identified. Recent commit broke database connection."
    ↓
Agent outputs: Detailed report with commit hash, explanation, and fix suggestion

When to Use AI Agents vs. Traditional Automation

Not every problem needs an AI agent. Here’s when each makes sense:

Use traditional CI/CD automation when:

The workflow is fully deterministic
You know all possible failure modes
Speed and cost are critical
Zero tolerance for unexpected behavior

Use AI agents when:

Failures require investigation and reasoning
Context matters (recent changes, system state, historical patterns)
The problem space is too large for explicit if-then rules
You need adaptive behavior

Examples:

Traditional automation: “If tests fail, don’t deploy” (simple rule)

AI agent: “Tests failed. Analyze which tests, check if they’re flaky, review recent code changes, determine if this is a real issue or infrastructure problem, suggest next steps” (complex reasoning)

What We’re Building Next

Now that you understand the components, we’re going to build a Pipeline Health Monitor Agent that uses:

LLM: GPT-4 or Claude for reasoning
Tools: GitHub API, log analysis, issue search
Memory: Conversation history for multi-step investigation
Prompts: DevOps-specific instructions with infrastructure context

In the next section, we’ll write the actual code.

Building Version 1: Pipeline Health Monitor Agent

Now we’re going to build a working AI agent that monitors your GitHub Actions workflows and investigates failures. This is production-ready code that you can deploy today.

What Our Agent Will Do

When a GitHub Actions workflow fails, our agent will:

Receive a webhook notification with the workflow ID
Fetch the workflow logs from GitHub
Analyze recent commits to find what changed
Search existing GitHub issues for similar errors
Use an LLM (GPT-4, Claude, or others via OpenRouter) to reason about the root cause
Generate a detailed report with recommendations

Let’s build it step by step.

Installation and Setup

First, install uv if you don’t have it already:

# On macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# On Windows
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

Create a new project directory and set up a virtual environment:

mkdir pipeline-agent
cd pipeline-agent

# Create virtual environment with uv
uv venv

# Activate the virtual environment
# On macOS/Linux:
source .venv/bin/activate

# On Windows:
.venv\Scripts\activate

Install the required dependencies using uv:

uv pip install langchain langchain-openai requests python-dotenv

Set up your environment variables in a .env file.

Option 1: Using OpenAI directly

OPENAI_API_KEY=your_openai_api_key_here
GITHUB_TOKEN=your_github_personal_access_token
GITHUB_REPO=username/repository
USE_OPENROUTER=false

Option 2: Using OpenRouter (recommended for cost savings)

OPENROUTER_API_KEY=your_openrouter_api_key_here
GITHUB_TOKEN=your_github_personal_access_token
GITHUB_REPO=username/repository
USE_OPENROUTER=true
MODEL_NAME=anthropic/claude-3.5-sonnet  # or openai/gpt-4, google/gemini-pro, etc.

Why OpenRouter?

Access multiple LLM providers through one API
Often cheaper than going direct (they negotiate bulk rates)
Easy to switch between models without changing code
Get API key at: https://openrouter.ai/

Step 1: Define the Tools

Tools are functions the agent can call. Each tool is decorated with @tool and includes a docstring that tells the LLM what it does.

# agent_investigator.py
import os
import requests
from datetime import datetime, timedelta
from typing import Optional
from langchain.tools import tool
from dotenv import load_dotenv

load_dotenv()

GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
GITHUB_REPO = os.getenv("GITHUB_REPO")
HEADERS = {
    "Authorization": f"token {GITHUB_TOKEN}",
    "Accept": "application/vnd.github.v3+json"
}

@tool
def get_workflow_logs(workflow_run_id: str) -> str:
    """
    Fetch logs from a failed GitHub Actions workflow run.

    Args:
        workflow_run_id: The GitHub Actions workflow run ID

    Returns:
        String containing the workflow logs
    """
    try:
        # Get workflow run details
        run_url = f"https://api.github.com/repos/{GITHUB_REPO}/actions/runs/{workflow_run_id}"
        run_response = requests.get(run_url, headers=HEADERS)
        run_response.raise_for_status()
        run_data = run_response.json()

        # Get jobs for this workflow run
        jobs_url = f"{run_url}/jobs"
        jobs_response = requests.get(jobs_url, headers=HEADERS)
        jobs_response.raise_for_status()
        jobs_data = jobs_response.json()

        # Extract logs from failed jobs
        logs = []
        logs.append(f"Workflow: {run_data['name']}")
        logs.append(f"Status: {run_data['conclusion']}")
        logs.append(f"Started: {run_data['created_at']}")
        logs.append(f"Branch: {run_data['head_branch']}\n")

        for job in jobs_data['jobs']:
            if job['conclusion'] == 'failure':
                logs.append(f"\nFailed Job: {job['name']}")
                logs.append(f"Conclusion: {job['conclusion']}")

                # Get job logs
                log_url = f"https://api.github.com/repos/{GITHUB_REPO}/actions/jobs/{job['id']}/logs"
                log_response = requests.get(log_url, headers=HEADERS)

                if log_response.status_code == 200:
                    # Extract last 50 lines (most relevant errors are at the end)
                    log_lines = log_response.text.split('\n')
                    relevant_logs = log_lines[-50:]
                    logs.append("\nLast 50 lines of logs:")
                    logs.append('\n'.join(relevant_logs))

        return '\n'.join(logs)

    except requests.exceptions.RequestException as e:
        return f"Error fetching workflow logs: {str(e)}"


@tool
def analyze_recent_commits(hours: int = 24) -> str:
    """
    Analyze recent commits to the repository that might have caused the failure.

    Args:
        hours: Number of hours to look back (default: 24)

    Returns:
        String containing recent commits with author, message, and files changed
    """
    try:
        since = (datetime.utcnow() - timedelta(hours=hours)).isoformat() + 'Z'
        commits_url = f"https://api.github.com/repos/{GITHUB_REPO}/commits"
        params = {'since': since, 'per_page': 10}

        response = requests.get(commits_url, headers=HEADERS, params=params)
        response.raise_for_status()
        commits = response.json()

        if not commits:
            return f"No commits found in the last {hours} hours."

        result = [f"Recent commits (last {hours} hours):\n"]

        for commit in commits:
            sha = commit['sha'][:7]
            author = commit['commit']['author']['name']
            message = commit['commit']['message'].split('\n')[0]  # First line only
            date = commit['commit']['author']['date']

            # Get files changed in this commit
            commit_detail_url = f"https://api.github.com/repos/{GITHUB_REPO}/commits/{commit['sha']}"
            commit_response = requests.get(commit_detail_url, headers=HEADERS)
            commit_data = commit_response.json()

            files_changed = [f['filename'] for f in commit_data.get('files', [])]

            result.append(f"\nCommit {sha} by {author} ({date})")
            result.append(f"Message: {message}")
            result.append(f"Files changed: {', '.join(files_changed[:5])}")  # First 5 files
            if len(files_changed) > 5:
                result.append(f"... and {len(files_changed) - 5} more files")

        return '\n'.join(result)

    except requests.exceptions.RequestException as e:
        return f"Error analyzing commits: {str(e)}"


@tool
def search_similar_issues(error_keywords: str) -> str:
    """
    Search GitHub issues for similar error messages or problems.

    Args:
        error_keywords: Keywords from the error message to search for

    Returns:
        String containing relevant GitHub issues and their solutions
    """
    try:
        # Search issues in the repository
        search_url = "https://api.github.com/search/issues"
        query = f"repo:{GITHUB_REPO} {error_keywords} is:issue"
        params = {'q': query, 'sort': 'relevance', 'per_page': 5}

        response = requests.get(search_url, headers=HEADERS, params=params)
        response.raise_for_status()
        issues = response.json()

        if issues['total_count'] == 0:
            return f"No similar issues found for keywords: {error_keywords}"

        result = [f"Found {issues['total_count']} similar issues:\n"]

        for issue in issues['items'][:5]:
            result.append(f"\n#{issue['number']}: {issue['title']}")
            result.append(f"State: {issue['state']}")
            result.append(f"URL: {issue['html_url']}")

            # Get first comment if issue is closed (might contain solution)
            if issue['state'] == 'closed' and issue['comments'] > 0:
                comments_url = issue['comments_url']
                comments_response = requests.get(comments_url, headers=HEADERS)
                comments = comments_response.json()
                if comments:
                    first_comment = comments[0]['body'][:200]  # First 200 chars
                    result.append(f"Solution hint: {first_comment}...")

        return '\n'.join(result)

    except requests.exceptions.RequestException as e:
        return f"Error searching issues: {str(e)}"

Step 2: Create the Agent with LLM Provider Support

Now we’ll create the agent with support for both OpenAI and OpenRouter:

from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

def get_llm():
    """
    Initialize the LLM based on environment configuration.
    Supports both OpenAI directly and OpenRouter.
    """
    use_openrouter = os.getenv("USE_OPENROUTER", "false").lower() == "true"

    if use_openrouter:
        # Using OpenRouter for access to multiple models
        api_key = os.getenv("OPENROUTER_API_KEY")
        model_name = os.getenv("MODEL_NAME", "anthropic/claude-3.5-sonnet")

        llm = ChatOpenAI(
            model=model_name,
            openai_api_key=api_key,
            openai_api_base="https://openrouter.ai/api/v1",
            temperature=0,
            default_headers={
                "HTTP-Referer": "https://github.com/your-username/pipeline-agent",
                "X-Title": "Pipeline Health Monitor Agent"
            }
        )
        print(f"Using OpenRouter with model: {model_name}")
    else:
        # Using OpenAI directly
        api_key = os.getenv("OPENAI_API_KEY")
        llm = ChatOpenAI(
            model="gpt-4",
            temperature=0,
            openai_api_key=api_key
        )
        print("Using OpenAI GPT-4")

    return llm

# Initialize the LLM
llm = get_llm()

# Define the system prompt
system_prompt = """You are an expert DevOps AI agent that investigates CI/CD pipeline failures.

Your role is to:
1. Analyze workflow logs to identify the root cause of failures
2. Examine recent code changes that might have introduced issues
3. Search for similar problems in the issue tracker
4. Provide a clear, actionable root cause analysis

When analyzing failures:
- Focus on the actual error messages, not just symptoms
- Consider recent code changes as potential causes
- Look for patterns in similar past issues
- Be specific about what broke and why
- Suggest concrete fixes, not vague advice

Your investigation should be thorough but concise. Developers need actionable insights, not lengthy explanations.

Output format:
**Root Cause**: [One sentence summary]
**Evidence**: [Key findings from logs/commits/issues]
**Recommendation**: [Specific steps to fix]
**Related Issues**: [Links to similar problems if found]
"""

# Create the prompt template
prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# Create the agent
tools = [get_workflow_logs, analyze_recent_commits, search_similar_issues]
agent = create_openai_tools_agent(llm, tools, prompt)

# Create the agent executor
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=5,
    handle_parsing_errors=True
)

Step 3: Run the Investigation

Finally, we create a function to trigger the investigation:

def investigate_failure(workflow_run_id: str) -> dict:
    """
    Investigate a failed GitHub Actions workflow.

    Args:
        workflow_run_id: The GitHub Actions workflow run ID

    Returns:
        Dict containing the investigation result
    """
    print(f"\nStarting investigation for workflow run {workflow_run_id}...")
    print("=" * 60)

    input_text = f"""A GitHub Actions workflow has failed (run ID: {workflow_run_id}).

Please investigate this failure by:
1. Fetching and analyzing the workflow logs
2. Checking recent commits for changes that might have caused this
3. Searching for similar issues that might provide insights

Provide a comprehensive root cause analysis with specific recommendations."""

    try:
        result = agent_executor.invoke({"input": input_text})

        print("\n" + "=" * 60)
        print("INVESTIGATION COMPLETE")
        print("=" * 60)
        print(result['output'])

        return {
            "success": True,
            "workflow_run_id": workflow_run_id,
            "analysis": result['output']
        }

    except Exception as e:
        print(f"\nError during investigation: {str(e)}")
        return {
            "success": False,
            "workflow_run_id": workflow_run_id,
            "error": str(e)
        }


if __name__ == "__main__":
    import sys

    if len(sys.argv) < 2:
        print("Usage: python agent_investigator.py <workflow_run_id>")
        sys.exit(1)

    workflow_run_id = sys.argv[1]
    investigate_failure(workflow_run_id)

Model Recommendations via OpenRouter

Here are some good model choices for DevOps investigations:

For best reasoning (higher cost):

anthropic/claude-3.5-sonnet - Excellent at technical analysis
openai/gpt-4-turbo - Strong general reasoning
google/gemini-pro-1.5 - Good for long context (helpful with large logs)

For cost efficiency (lower cost):

anthropic/claude-3-haiku - Fast and cheap, good for simple failures
openai/gpt-3.5-turbo - Decent reasoning, very affordable
meta-llama/llama-3.1-70b-instruct - Open source, cost-effective

Cost comparison per investigation:

GPT-4: ~$0.15-0.30
Claude 3.5 Sonnet: ~$0.10-0.20
GPT-3.5: ~$0.02-0.05
Llama 3.1 70B: ~$0.01-0.03

How It Works

Let’s walk through what happens when you run this:

You trigger the agent: python agent_investigator.py 12345678
Agent receives the task: “Investigate workflow run 12345678”
LLM decides first action: “I should fetch the workflow logs to see what failed”
Agent calls get_workflow_logs(): Returns the last 50 lines of failed job logs
LLM analyzes logs: “I see a database connection error. Let me check recent commits for database config changes”
Agent calls analyze_recent_commits(): Returns commits from the last 24 hours
LLM finds suspicious commit: “Commit abc123 changed database.yml. Let me search for similar issues”
Agent calls search_similar_issues(): Finds issue #42 about database connection problems
LLM synthesizes findings: Produces a final report with root cause and fix

The entire process takes 10-30 seconds depending on the complexity.

Example Output

Here’s what the agent produces for a real failure:

Root Cause: Database connection pool exhaustion caused by recent increase in concurrent workers without adjusting max_connections setting.

Evidence:
- Workflow logs show "psycopg2.OperationalError: FATAL: sorry, too many clients already"
- Commit d4e5f6a (2 hours ago) changed worker count from 4 to 16 in deploy.yml
- Issue #127 documented same error when worker count was increased last month

Recommendation:
1. Increase PostgreSQL max_connections from 100 to 200 in database config
2. Or reduce worker count back to 8 as a temporary fix
3. Add connection pooling with PgBouncer for better resource management

Related Issues:
- #127: Database connection errors after scaling workers
- #89: PostgreSQL connection pool configuration guide

This is exactly what you need: the root cause, evidence, and actionable fixes.

Key Design Decisions

Why max_iterations=5? Prevents infinite loops. Most investigations complete in 3-4 iterations.

Why last 50 lines of logs? Error messages are typically at the end. Sending full logs wastes tokens and costs money.

Why temperature=0? We want deterministic, factual analysis. Higher temperature adds creativity, which we don’t need for debugging.

Why support OpenRouter? Gives you flexibility to switch models based on cost and performance. Claude 3.5 Sonnet often performs better than GPT-4 for technical debugging at a lower price.

In the next section, we’ll integrate this agent with GitHub Actions so it runs automatically when workflows fail.

GitHub Actions Integration

Now that we have a working agent, let’s integrate it with GitHub Actions so it automatically investigates failures. We’ll use GitHub’s workflow events to trigger our agent whenever a pipeline fails.

Architecture Overview

Here’s how the integration works:

GitHub Actions Workflow Fails
    ↓
GitHub triggers workflow_run event
    ↓
Our "Investigate Failure" workflow runs
    ↓
Calls agent_investigator.py with workflow ID
    ↓
Agent investigates and generates report
    ↓
Posts results to GitHub issue or Slack

Step 1: Set Up GitHub Secrets

First, add your API keys to GitHub repository secrets:

Go to your repository on GitHub
Click Settings > Secrets and variables > Actions
Click New repository secret
Add these secrets:

OPENAI_API_KEY (or OPENROUTER_API_KEY)
GITHUB_TOKEN (automatically provided by GitHub Actions)
SLACK_WEBHOOK_URL (optional, for notifications)

For OpenRouter users, also add:

USE_OPENROUTER=true
MODEL_NAME=anthropic/claude-3.5-sonnet

Step 2: Create the Investigation Workflow

Create a new file .github/workflows/investigate-failures.yml:

name: AI Agent - Investigate Failures

on:
  workflow_run:
    workflows: ["*"]  # Monitor all workflows
    types:
      - completed

jobs:
  investigate:
    # Only run if the workflow failed
    if: $
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install uv
        run: |
          curl -LsSf https://astral.sh/uv/install.sh | sh
          echo "$HOME/.cargo/bin" >> $GITHUB_PATH

      - name: Create virtual environment and install dependencies
        run: |
          uv venv
          source .venv/bin/activate
          uv pip install langchain langchain-openai requests python-dotenv

      - name: Run AI investigation
        env:
          GITHUB_TOKEN: $
          GITHUB_REPO: $
          OPENAI_API_KEY: $
          OPENROUTER_API_KEY: $
          USE_OPENROUTER: $
          MODEL_NAME: $
        run: |
          source .venv/bin/activate
          python agent_investigator.py $

      - name: Post results to GitHub issue
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');

            // Read the investigation results
            const workflowName = '$';
            const workflowUrl = '$';
            const runId = '$';

            // Create or update issue with findings
            const title = `Pipeline Failure: ${workflowName}`;
            const body = `## Automated Investigation Report

**Workflow**: [${workflowName}](${workflowUrl})
**Run ID**: ${runId}
**Branch**: $
**Commit**: $

### Investigation Results

The AI agent has completed its investigation. Check the workflow logs for detailed analysis.

**Next Steps**:
1. Review the root cause analysis above
2. Check the recommended fixes
3. Review related issues if any were found
4. Apply the fix and re-run the workflow

---
*This issue was automatically created by the Pipeline Health Monitor AI Agent*
`;

            // Search for existing open issue
            const issues = await github.rest.issues.listForRepo({
              owner: context.repo.owner,
              repo: context.repo.repo,
              state: 'open',
              labels: ['pipeline-failure', 'ai-investigated']
            });

            const existingIssue = issues.data.find(issue =>
              issue.title.includes(workflowName)
            );

            if (existingIssue) {
              // Update existing issue
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: existingIssue.number,
                body: `## New Failure Detected\n\n${body}`
              });
            } else {
              // Create new issue
              await github.rest.issues.create({
                owner: context.repo.owner,
                repo: context.repo.repo,
                title: title,
                body: body,
                labels: ['pipeline-failure', 'ai-investigated']
              });
            }

How It Works in Production

Once deployed, here’s what happens automatically:

Developer pushes code that breaks a test
CI pipeline fails (tests, build, deployment, etc.)
GitHub triggers the workflow_run event
Investigation workflow starts within seconds
Agent fetches logs, analyzes commits, searches issues
LLM reasons about the root cause
Results posted to GitHub issue and Slack
Developer sees detailed analysis with fix recommendations

All of this happens in 30-60 seconds after the failure.

Cost Considerations

Each investigation costs approximately:

GPT-4: $0.15-0.30 per investigation
Claude 3.5 Sonnet (via OpenRouter): $0.10-0.20
GPT-3.5: $0.02-0.05

For a team with:

20 pipeline failures per day
Using Claude 3.5 Sonnet ($0.15 average)

Monthly cost: 20 × $0.15 × 30 = $90

Compare this to:

Developer time investigating failures: 30 min × 20 failures = 10 hours/day
At $100/hour = $1,000/day saved

The ROI is clear.

Security Validation: The 48% Vulnerability Problem

Here’s the uncomfortable truth: research shows that 48% of AI-generated code contains vulnerabilities. In some studies, 60% of AI suggestions for financial services contained high-severity security flaws.

As DevOps consultants, we can’t afford to blindly trust AI-generated recommendations. Our agent has read access to logs, commits, and issues, but what if we extend it to execute fixes automatically? We need layers of security validation.

The Real Security Risks

Before we dive into solutions, let’s understand what can go wrong:

Prompt Injection Attacks: Google’s security team demonstrated a real exploit where hidden HTML comments in a dependency’s README convinced a build agent that a malicious package was legitimate. The agent shipped the malicious code to production.

Hallucinated Commands: An LLM might confidently suggest running kubectl delete deployment production when it meant to suggest kubectl delete pod production-5f6h8.

Information Leakage: Agents with access to logs might inadvertently expose secrets, API keys, or sensitive data when posting to public channels.

Shadow AI: Developers creating custom agents without proper governance, leading to unauthorized automation running in your pipelines.

Let’s build defenses against all of these.

Layer 1: Restrict Agent Permissions

The principle of least privilege applies to AI agents just like any other system component.

Our current agent only has read-only access:

# Current tools - all read-only
tools = [
    get_workflow_logs,       # Read GitHub logs
    analyze_recent_commits,  # Read git history
    search_similar_issues    # Read GitHub issues
]

This is intentional. Investigation does not require execution.

Layer 2: Secrets Detection

Never let the agent expose secrets in logs or notifications.

Create a secrets scanner:

# secrets_scanner.py
import re
from typing import List, Tuple

class SecretsScanner:
    """Detect and redact secrets from agent outputs."""

    PATTERNS = {
        'aws_key': r'AKIA[0-9A-Z]{16}',
        'github_token': r'gh[pousr]_[A-Za-z0-9_]{36,255}',
        'generic_api_key': r'api[_-]?key["\']?\s*[:=]\s*["\']?([a-zA-Z0-9_\-]{20,})',
        'password': r'password["\']?\s*[:=]\s*["\']?([^\s"\']{8,})',
        'private_key': r'-----BEGIN (RSA |OPENSSH )?PRIVATE KEY-----',
        'jwt': r'eyJ[A-Za-z0-9-_=]+\.eyJ[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*',
        'connection_string': r'(postgres|mysql|mongodb)://[^:]+:[^@]+@',
    }

    @staticmethod
    def scan(text: str) -> Tuple[bool, List[str]]:
        """
        Scan text for secrets.

        Args:
            text: Text to scan

        Returns:
            Tuple of (has_secrets, list of secret types found)
        """
        found_secrets = []

        for secret_type, pattern in SecretsScanner.PATTERNS.items():
            if re.search(pattern, text, re.IGNORECASE):
                found_secrets.append(secret_type)

        return (len(found_secrets) > 0, found_secrets)

    @staticmethod
    def redact(text: str) -> str:
        """
        Redact secrets from text.

        Args:
            text: Text to redact

        Returns:
            Text with secrets replaced by [REDACTED]
        """
        redacted = text

        for secret_type, pattern in SecretsScanner.PATTERNS.items():
            redacted = re.sub(pattern, f'[REDACTED:{secret_type.upper()}]', redacted, flags=re.IGNORECASE)

        return redacted


# Usage in agent output
def safe_output(text: str) -> str:
    """Process agent output to remove secrets before displaying."""
    scanner = SecretsScanner()
    has_secrets, secret_types = scanner.scan(text)

    if has_secrets:
        print(f"WARNING: Detected secrets in output: {', '.join(secret_types)}")
        return scanner.redact(text)

    return text

Update the investigation function to use secrets scanning:

def investigate_failure(workflow_run_id: str) -> dict:
    """Investigate a failed GitHub Actions workflow with secret protection."""
    # ... existing code ...

    try:
        result = agent_executor.invoke({"input": input_text})

        # Scan for secrets before outputting
        safe_analysis = safe_output(result['output'])

        print("\n" + "=" * 60)
        print("INVESTIGATION COMPLETE")
        print("=" * 60)
        print(safe_analysis)

        return {
            "success": True,
            "workflow_run_id": workflow_run_id,
            "analysis": safe_analysis
        }
    except Exception as e:
        return {
            "success": False,
            "workflow_run_id": workflow_run_id,
            "error": str(e)
        }

Layer 3: Audit Trail

Log every agent decision for security review and debugging.

# audit_logger.py
import json
from datetime import datetime
from pathlib import Path
from typing import Dict, Any

class AuditLogger:
    """Log all agent actions for security auditing."""

    def __init__(self, log_dir: str = ".agent_logs"):
        self.log_dir = Path(log_dir)
        self.log_dir.mkdir(exist_ok=True)

    def log_investigation(self, event_data: Dict[str, Any]):
        """
        Log an investigation event.

        Args:
            event_data: Dictionary containing event details
        """
        timestamp = datetime.utcnow().isoformat()
        log_entry = {
            "timestamp": timestamp,
            "event_type": "investigation",
            **event_data
        }

        # Log to daily file
        log_file = self.log_dir / f"audit_{datetime.utcnow().strftime('%Y-%m-%d')}.jsonl"

        with open(log_file, 'a') as f:
            f.write(json.dumps(log_entry) + '\n')

    def log_tool_call(self, tool_name: str, args: Dict, result: Any, duration: float):
        """Log a tool call."""
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "event_type": "tool_call",
            "tool": tool_name,
            "arguments": args,
            "result_preview": str(result)[:200],
            "duration_seconds": duration
        }

        log_file = self.log_dir / f"audit_{datetime.utcnow().strftime('%Y-%m-%d')}.jsonl"

        with open(log_file, 'a') as f:
            f.write(json.dumps(log_entry) + '\n')

    def log_security_event(self, event_type: str, details: Dict[str, Any]):
        """Log a security-related event."""
        log_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "event_type": "security",
            "security_event": event_type,
            **details
        }

        log_file = self.log_dir / f"security_{datetime.utcnow().strftime('%Y-%m-%d')}.jsonl"

        with open(log_file, 'a') as f:
            f.write(json.dumps(log_entry) + '\n')

Layer 4: Rate Limiting and Cost Controls

Prevent runaway costs and API abuse:

# rate_limiter.py
import time
from collections import deque
from datetime import datetime, timedelta

class RateLimiter:
    """Rate limit agent executions to prevent abuse and control costs."""

    def __init__(self, max_investigations_per_hour: int = 20):
        self.max_per_hour = max_investigations_per_hour
        self.investigation_times = deque()

    def can_investigate(self) -> bool:
        """Check if we can run another investigation."""
        now = datetime.utcnow()
        cutoff = now - timedelta(hours=1)

        # Remove investigations older than 1 hour
        while self.investigation_times and self.investigation_times[0] < cutoff:
            self.investigation_times.popleft()

        return len(self.investigation_times) < self.max_per_hour

    def record_investigation(self):
        """Record that an investigation occurred."""
        self.investigation_times.append(datetime.utcnow())

    def time_until_next_allowed(self) -> int:
        """Get seconds until next investigation is allowed."""
        if self.can_investigate():
            return 0

        oldest = self.investigation_times[0]
        time_until_allowed = (oldest + timedelta(hours=1)) - datetime.utcnow()
        return int(time_until_allowed.total_seconds())

Security Checklist

Before deploying your AI agent to production, verify:

Agent has minimum required permissions (read-only by default)
All commands validated before execution
Secrets scanner active on all outputs
Audit logging enabled and monitored
Rate limiting configured
GitHub tokens scoped correctly (no admin access)
LLM API keys stored in secrets, not code
No secrets committed to repository
Slack webhooks use incoming webhook URLs only
Agent cannot modify production without approval

Real-World Security Scenario

Here’s how these layers work together:

Agent investigates failure and LLM suggests: kubectl delete pod production-db-0
Command validator catches this: “APPROVAL REQUIRED: Command requires human approval”
Agent posts recommendation to GitHub issue instead of executing
Secrets scanner detects database connection string in logs and redacts it
Audit logger records the attempted command and approval requirement
Human reviews the recommendation and decides whether to execute
If approved, human runs command manually with full context

The agent accelerates investigation but humans retain control over critical actions.

Practical Tips and Common Pitfalls

After building and running AI agents for DevOps investigations, I’ve learned what works and what doesn’t. Here are the hard-earned lessons that will save you time and money.

Prompt Engineering Best Practices

Your prompt is the most important part of your agent. A vague prompt gives vague results. A specific prompt with context gives actionable insights.

Bad Prompt:

system_prompt = """You are an AI agent. Debug the issue."""

Why it fails: Too generic, no context, no output format.

Good Prompt:

system_prompt = """You are an expert DevOps AI agent that investigates CI/CD pipeline failures.

Infrastructure context:
- Python microservices running on Kubernetes in AWS EKS
- PostgreSQL 14 database with connection pooling
- Redis for caching
- GitHub Actions for CI/CD

Your role is to:
1. Analyze workflow logs to identify the root cause of failures
2. Examine recent code changes that might have introduced issues
3. Search for similar problems in the issue tracker
4. Provide a clear, actionable root cause analysis

When analyzing failures:
- Focus on the actual error messages, not just symptoms
- Consider recent code changes as potential causes
- Look for patterns in similar past issues
- Be specific about what broke and why
- Suggest concrete fixes, not vague advice

Output format:
**Root Cause**: [One sentence summary]
**Evidence**: [Key findings from logs/commits/issues]
**Recommendation**: [Specific steps to fix]
**Related Issues**: [Links to similar problems if found]
"""

Why it works: Infrastructure context, clear role, specific instructions, defined output format.

Common Pitfalls and Solutions

Pitfall 1: Agent Loops Infinitely

Symptom: Agent keeps calling tools without making progress.

Solution: Set max_iterations:

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=5,  # Stop after 5 iterations
    handle_parsing_errors=True
)

Pitfall 2: Costs Spiral Out of Control

Symptom: Your OpenAI bill is $500 for 100 investigations.

Cause: Using GPT-4 for everything, not optimizing token usage.

Solution: Use the right model for the task:

def get_llm(task_complexity: str = "medium"):
    """Choose LLM based on task complexity."""

    if task_complexity == "simple":
        # Use cheaper model for simple log analysis
        model = "gpt-3.5-turbo"  # $0.002 per investigation
    elif task_complexity == "medium":
        model = "anthropic/claude-3.5-sonnet"  # $0.15 per investigation
    else:  # complex
        model = "openai/gpt-4"  # $0.30 per investigation

    return ChatOpenAI(model=model, temperature=0)

Cost comparison:

GPT-4: $0.30 per investigation
Claude 3.5 Sonnet: $0.15 per investigation
GPT-3.5: $0.02 per investigation

For 100 investigations/month:

All GPT-4: $30
All GPT-3.5: $2
Mixed (80% GPT-3.5, 20% GPT-4): $6.80

Pitfall 3: Secrets Leak in Logs

Symptom: API keys visible in agent output.

Solution: Always scan output (from the security section):

from secrets_scanner import safe_output

result = agent_executor.invoke({"input": input_text})
safe_result = safe_output(result['output'])  # Redacts secrets

Performance Benchmarks

From my production deployments:

Investigation time:

Simple failures (import errors): 10-15 seconds
Medium complexity (config issues): 20-30 seconds
Complex failures (race conditions): 45-60 seconds

Accuracy:

Correct root cause identified: 78% of cases
Helpful suggestions even when wrong: 92% of cases
Completely useless output: 8% of cases

Cost per investigation:

GPT-3.5: $0.02-0.05
Claude 3.5 Sonnet: $0.10-0.20
GPT-4: $0.15-0.30

Developer time saved:

Average investigation time (manual): 25 minutes
Average investigation time (agent): 30 seconds
Time saved: 24.5 minutes per failure

For 20 failures/day: 490 minutes = 8+ hours saved daily.

Quick Reference: Dos and Don’ts

DO:

Set max_iterations to prevent loops
Add timeouts to all API calls
Scan outputs for secrets
Log all agent decisions
Use structured output formats
Cache frequent queries
Choose models based on complexity
Test prompts in isolation first

DON’T:

Give agents write access without validation
Trust AI-generated commands blindly
Send full logs (use last 50 lines)
Use GPT-4 for everything (cost optimization)
Ignore rate limits
Commit API keys to git
Skip error handling
Deploy without testing

Next Steps and Extensions

You’ve built a working AI agent that automatically investigates pipeline failures. But this is just the beginning. Here are practical ways to extend and improve your agent.

What You’ve Built

Let’s recap what your agent can do:

Monitor GitHub Actions workflows automatically
Investigate failures within 30 seconds
Fetch and analyze workflow logs
Examine recent code changes
Search for similar issues
Generate root cause analysis with recommendations
Redact secrets from outputs
Log all actions for audit
Rate limit to control costs
Post results to GitHub issues

Extension Ideas

1. Multi-Agent System

Create specialist agents for different tasks:

# Build Agent: Optimizes build performance
build_agent = create_agent(
    tools=[analyze_build_logs, suggest_caching, optimize_dependencies],
    role="Build Optimization Specialist"
)

# Security Agent: Scans for vulnerabilities
security_agent = create_agent(
    tools=[scan_dependencies, check_secrets, validate_configs],
    role="Security Analyst"
)

# Deploy Agent: Manages deployments
deploy_agent = create_agent(
    tools=[check_health, deploy_staging, rollback_if_needed],
    role="Deployment Specialist"
)

2. Kubernetes Integration

Add tools for Kubernetes operations:

@tool
def get_pod_status(namespace: str, pod_name: str) -> str:
    """Get Kubernetes pod status and recent events."""
    pass

@tool
def analyze_pod_logs(namespace: str, pod_name: str) -> str:
    """Fetch and analyze pod logs."""
    pass

3. Learning from History

Implement long-term memory with a vector database:

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# Store past investigations
vectorstore = Chroma(
    collection_name="investigation_history",
    embedding_function=OpenAIEmbeddings()
)

# When investigating a new failure
similar_cases = vectorstore.similarity_search(
    error_message,
    k=3  # Find 3 most similar past failures
)

This lets your agent learn from experience.

Resources and Further Learning

LangChain Documentation

OpenRouter

Security Resources

OWASP LLM Top 10

Final Thoughts

AI agents aren’t replacing DevOps engineers. They’re accelerating investigation, reducing toil, and freeing you to focus on higher-value work.

The agent we built is read-only by design. It investigates and recommends, but humans make the final decisions. This is the right balance for production systems in 2025.

Start small:

Deploy the read-only investigation agent
Monitor its accuracy for a few weeks
Tune prompts based on results
Gradually add more capabilities
Always maintain human oversight

Over the past 2 years as a DevOps consultant, I’ve seen teams waste countless hours on repetitive failure investigations. This agent solves that problem.

The code is production-ready. The security is enterprise-grade. The cost is negligible compared to developer time saved.

What are you waiting for? Give your CI/CD pipeline a brain.

Want to Learn More?

If you’re interested in deepening your DevOps and systems programming knowledge, check out Educative.io’s Unlimited Plan - it’s an excellent resource for hands-on learning with interactive courses.

If you found this helpful, share it on X and tag me @muhammad_o7 - I’d love to hear your thoughts! You can also connect with me on LinkedIn.

Need Help? I’m available for Python and DevOps consulting. If you need help with CI/CD, automation, infrastructure, or AI agents for your DevOps workflows, reach out via email or DM me on X/Twitter.

The Drawbacks of using AWS SageMaker Feature Store

vladsiv — Tue, 25 Nov 2025 02:00:00 GMT

This post breaks down the key drawbacks of SageMaker Feature Store that teams often encounter when scaling ML workflows. By understanding these limitations early, you can make more informed architectural decisions and avoid unnecessary complexity later on.

From Pages to Workers (again): revisited

brycewray.com — Mon, 24 Nov 2025 22:44:00 GMT

Getting the straight story from one who definitely knows what’s what at Cloudflare.

Skin pathology in ALS

Padirac Innovations' blog — Mon, 24 Nov 2025 19:31:50 GMT

Evidence of pre-symptomatic TDP-43 pathology across diverse non-CNS peripheral tissues, including skin, decades before ALS symptom onset...

Flask started as an April Fool's joke

Nicola Iarocci — Mon, 24 Nov 2025 16:29:19 GMT

The story that the Python micro web framework Flask started as an April Fool’s joke is well known in Python circles, but it was nice to see it told by Armin Ronacher himself¹.

I’m fond of Flask. It was a breath of fresh air when it came out, and most of my Python open-source work is based on it.

The video is produced by the people who also authored the remarkable Python: The Documentary. ↩︎

Phonetica Game Dev Log

Alexander Whillas — Mon, 24 Nov 2025 13:00:00 GMT

A new game I’m working on to help kids learn to read by sounding out words.

Lestrarvinur - Flettispjaldaleikur (“flash cards”) með 100 algengustu íslensku orðunum

joisig gone awol — Mon, 24 Nov 2025 11:31:31 GMT

TL;DR: This will only be interesting for those who have young kids (1st/2nd grade roughly) learning to read in Icelandic, it’s a flash card game with the 100 most common Icelandic words. Thus the rest of this is in Icelandic.

TL;DR á íslensku: Leikurinn er hér 😃

VSCode Insiders Podcast

Eleanor on Everything — Mon, 24 Nov 2025 10:26:05 GMT

Had fun chatting with Pamela Fox on AI assisted coding

SitStand - Controlling My Standing Desk with Bluetooth

Greg's Half Ideas — Mon, 24 Nov 2025 06:25:32 GMT

Building a BLE controller for UPLIFT and Jiecang standing desks with CLI commands, a web dashboard, and activity tracking

Gemini 3

Zappable — Mon, 24 Nov 2025 05:48:57 GMT

Gemini 3 and Nano Banana Pro were announced last week along with a few other new features and tools:

BazelCon 2025 recap

Julio Merino's corner on Julio Merino (jmmv.dev) — Mon, 24 Nov 2025 03:00:00 GMT

It has been just over two years since I started Blog System/5, and that means it’s time for the now-usual(?) BazelCon 2025 trip report!

The conference, arranged by the Linux Foundation, took place in Atlanta, GA, USA over three days: one for tutorials and two for the main talks. An extra hackathon day, organized by Aspect Build, followed. Unfortunately, a canceled flight meant I missed the tutorials, but I attended the rest of the events. As usual, it was a super-fun time to connect with old acquaintances and an energizing event that left me with plenty of new topics to research.

Granola AI Review: The App I Use Every Meeting

Zachary Proser — Mon, 24 Nov 2025 02:00:00 GMT

After months of daily use, Granola replaced my entire note-taking workflow. No bots, no awkward recordings — just clean AI notes.

WhatsApp from you know where

xenodium.com @alvaro — Mon, 24 Nov 2025 02:00:00 GMT

While there are plenty of messaging alternatives out there, for better or worse, WhatsApp remains a necessity for some of us.

With that in mind, I looked for ways to bring WhatsApp messaging to the comfort of my beloved text editor.

As mentioned in my initial findings, WhatsApp on Emacs is totally doable with the help of wuzapi and whatsmeow, which offer a huge leg up.

Wasabi joins the chat

Today, I introduce a super early version of Wasabi, a native Emacs interface for WhatsApp messaging.

Simple install as a feature/goal

I wanted Wasabi installation/setup to be as simple as possible. Ideally, you install a single Emacs package and off you go.

While leveraging XMPP is rather appealing in reusing existing Emacs messaging packages, I felt setting up a WhatsApp gateway or related infrastructure to be somewhat at odds with wasabi's simple installation goal. Having said that, wuzapi/whatsmeow offer a great middle ground. You install a single binary dependency, along with wasabi, and you're ready to go. This isn't too different from the git + magit combo.

As of now, wasabi's installation/setup boils down to two steps if you're on macOS:

(use-package wasabi
  :ensure t
  :vc (:url "https://github.com/xenodium/wasabi" :branch "main"))

brew install asternic/wuzapi/wuzapi

While you may try Homebrew on Linux, you're likely to prefer your native package manager. If that fails, building wuzapi from source is also an option.

Upstreaming `wuzapi` patches

While wuzapi runs as a RESTful API service + webhooks, I wanted to simplify the Emacs integration by using json-rpc over standard I/O, enabling us to leverage incoming json-rpc notifications in place of webhooks.

I floated the idea of adding json-rpc to wuzapi to wuzapi's author Nicolas, and to my delight, he was keen on it. He's now merged my initial proof of concept, and I followed up with a handful of additional patches (all merged now):

Early days - But give it a try!

With the latest Wasabi Emacs package and wuzapi binary, you now get the initial WhatsApp experience I've been working towards. At present, you can send/receive messages to/from 1:1 or group chats. You can also download/view images as well as videos. Viewing reactions is also supported.

Needless to say, you may find some initial rough edges in addition to missing features. Having said that, I'd love to hear your feedback and experience. As mentioned Wasabi is currently available on GitHub.

Reckon Wasabi is worth it?

I've now put in quite a bit of effort prototyping things, upstreaming changes to wuzapi, and building the first iteration of wasabi. I gotta say, it feels great to be able to quickly message and catch up with different chats from the comfort of Emacs. Having said that, it's taken a lot of work to get here and will require plenty more to get to a polished and featureful experience.

Since going full-time indie dev, I have the flexibility to work on projects of choice, but that's only to an extent. If I cannot make the project sustainable, I'll eventually move to work on something else that is.

If you're keen on Wasabi's offering, please consider sponsoring the effort, and please reach out to voice your interest (Mastodon / Twitter / Reddit / Bluesky).

Reckon a WhatsApp Emacs client would help you stay focused at work (less time on your phone)? Ask your employer to sponsor it too ;-)

What's New In The 2025-11-25 MCP Authorization Spec

Den Delimarsky — Mon, 24 Nov 2025 02:00:00 GMT

Get a sneak peek on what’s changing in the new authorization specification for MCP that will land with the new spec release.

Avoid Interview Prep Courses

Agentultra — Mon, 24 Nov 2025 02:00:00 GMT

Musings and ramblings on programming and things

Search with broot - the good moves

dystroy|Canop / blog — Mon, 24 Nov 2025 02:00:00 GMT

This article is both for people who don't know broot yet, and for those who do but are probably less efficient at searching than they could be.

Automating updates to a digital vigil

ntietz.com blog - technically a blog — Mon, 24 Nov 2025 02:00:00 GMT

November 20th each year is Transgender Day of Remembrance (TDoR). It is a day when we memorialize those who've been lost to transphobia, through violence or suicide. And each year, I make the most difficult git commit of the year, updating the list of names in the digital vigil that I made a few years ago.

I was late doing it this year, and I did it on November 20th last year. Ideally, it would be done early. I keep procrastinating it, because it's tough emotional work. Next year, I want it to be early, so... how do I actually get myself to do that?

The solution is either more therapy or more automation. So naturally, I decided on the automation! (Don't worry, I have a therapist that I love.)

We'll need to solve two main problems: updating the lists of names, and deploying it on a schedule.

Updating the names

The digital vigil is a static site, and we need to know all the names when it's built. All the names are stored in a couple of arrays of strings in a Rust file^[1]. We'll want to update that file, which means we get to do codegen, baby!

Let's tackle getting the names first.

An authoritative source of names for TDoR vigils is the website Trans Lives Matter. This is where I download the report from each year for manual updates. It's a great source of data, and I'm only using a fraction of what is there.

I decided to write a Python script to pull the data. I got partway through the script using the same endpoint the human-consumable webpage offers for a download, when I realized it gives me a zip file. After opening a few too many tabs, I remembered: there's an API for this! Of course there's an API, and like all principal engineers working on their hobby projects, I didn't remember to check the obvious things first^[2]. After switching to the API, I got JSON directly, and the data was super easy to retrieve.

Here's what that looks like.

api_key = os.environ.get("TDOR_API_KEY")

def get_report(year, country="all"):
    """Retrieves the data for a given year's vigil.

    This will request the data from September 30 of the previous year through
    October 1 of the requested year.

    Params:
        - year:     (int) what year's vigil the data is for
        - country:  (str) scope of the data; default="all"

    """

    from_date = f"{year-1}-10-01"
    to_date = f"{year}-09-30"

    headers = { "User-Agent": "tdor-digital-vigil-bot" }
    path = f"/api/v1/reports/?key={api_key}&from={from_date}&to={to_date}&country={country}&category=&filter="

    conn = http.client.HTTPSConnection("tdor.translivesmatter.info")
    conn.request("GET", path, None, headers)

    resp = conn.getresponse()

    if resp.status != 200:
        print(f"Error: expected 200, got {resp.status} ({resp.reason})")
        exit(1)

    body = resp.read()
    data = json.loads(body)

    return data

The next portion is fun and straightforward: turning this into some Rust code! "Codegen" can make it sound fancy, but for a lot of problems like this, codegen can be really simple.

In this case, we just have a file that has two static arrays in it. The code generation is really easy: iterate through our list of names, but bracket them with lines that start and end our declarations.

It looks like this.

usa_data = get_report(2025, "usa")
all_data = get_report(2025, "all")

with open("src/names.rs", "w+") as f:
    all_names = [r["name"] for r in all_data["data"]["reports"]]
    usa_names = [r["name"] for r in usa_data["data"]["reports"]]

    f.write(f"pub const FULL_NAMES: [&'static str; {len(all_names)}] = [\n")
    for name in all_names:
        f.write(f"    \"{name.replace("\"", "\\\"")}\",\n")
    f.write("];\n");

    f.write("\n")

    f.write(f"pub const US_NAMES: [&'static str; {len(usa_names)}] = [\n")
    for name in usa_names:
        f.write(f"    \"{name.replace("\"", "\\\"")}\",\n")
    f.write("];\n");

And generates a file like this.

pub const FULL_NAMES: [&'static str; 367] = [
    "Name Withheld",
    ...
];


pub const US_NAMES: [&'static str; 69] = [
    ...
];

It worked the first time! Definitely did not take me a few rounds of fixing silly bugs, no, definitely not. Anyway!

We've got that settled for this year. Now we need to automate it.

Deploying on a schedule

The first thing I did here was turn to my favorite simple automation solutions: Jenkins and Kubernetes. Of course, where's the fun in thinking about it ourselves? Let's vibe code it. I'll fire up Cursor using the latest Claude models and we can roll.

...

Ahahahaha no.

I'm not going to vibe code a single thing, especially not on something so dear to me as this. And we're not going to use Jenkins or Kubernetes here. Not that I don't love them (I don't, but that's beside the point), there's just no reason to use them for this.

And here, we don't need much technology at all. This could definitely be automated, to have deploys happen on a schedule without my involvement. But... all those systems would be a little fragile, and if you run a deploy once a year, it's going to break. Then you also need notifications for failures, and notifications for notification failures^[3].

That's a lot of complexity for very little effort saved each year. The problem I have isn't that the build is complicated. I just run make build then make deploy. The problem is that I forget.

And how do we solve forgetting? Reminders.

I'll be reminded next year on October 15th to update the digital vigil.

* * *

Automation can be hard, but I think the hardest thing about it is knowing where to strike the balance. What should you put in the effort for, and what should you just keep doing by hand?

For this problem, part of it benefited from automation code, and the other half from just setting myself reminders. It is all about reducing friction.

Okay, now I've made the hardest commit of the year, and I've written about it. I'm steeped in some emotions right now, so I'm going to go hug my wife and have some chocolate. Take care of yourself, and remember that you are loved.

I know I'm a walking stereotype ("oh look, the trans woman loves Rust"). It's not my fault, I'm just that cool. ↩
Look, it's not my fault my brain turns off after hours. I'm just adhering to the old woodworking maxim: measure once, cut twice. ↩
It's notifications for failures all the way down. ↩

In sunshine or in shadow

Something About Cats — Mon, 24 Nov 2025 01:28:43 GMT

Saying goodbye to my four-legged friend

Italy workation, Romania, and Portugal ✈️

Liza Shulyayeva — Sun, 23 Nov 2025 23:01:33 GMT

The last couple of months have been quite a bit of traveling. Two pre-planned trips and one quite impromptu one to just get away somewhere warm for a bit.

Interessant3 #168 | 🧠Constitution of Innovation, 🏛️Roman Labour Supply, 👶Global Poverty News

Interessant3 — Sun, 23 Nov 2025 22:15:32 GMT

Three Interesting Things for W/C 2025-11-23

We Who Endure

Digital Apocrypha — Sun, 23 Nov 2025 17:06:14 GMT

A short piece provoked by a recent day spent chopping wood. Link

Microservices

Gaganpreet Arora — Sun, 23 Nov 2025 15:03:52 GMT

We’ve been expanding the team at DigiUsher. I’ve interviewed dozens of engineers. I noticed a pattern: almost everyone defaults to microservices when conversation moves to system design. When I ask why, the answers are often vague. In my experience, it’s the same set of engineers who haven’t yet been exposed to the overhead of a new microservice.

I have yet to see a microservice architecture that doesn’t carry significant unnecessary complexity compared to a well-built monolith.

War Machine

mbutler — Sun, 23 Nov 2025 04:39:04 GMT

Because I need to numerically simulate castle sieges, I also need to simulate an economy capable of supporting both castles and sieges. To seed that economy, I need ruins of an old civilization, along with enough old coin to make those ruins matter. From there, everything else follows. War Machine is the dungeon productivity tool […]

Neuron Models

Ben Bolte — Sun, 23 Nov 2025 02:00:00 GMT

Interactive visualizations of various types of neuron models.

Budapest, 2025

Avy Faingezicht — Sun, 23 Nov 2025 02:00:00 GMT

Following our Vienna visit, we headed to Budapest. We could immediately tell Budapest was the poorer sibling. It felt a lot more run down, but the city is still beautiful, has a lot of history, great wine, and many things to see and do. I wanted to take a boat from Vienna, but instead we took a train ride - I fumbled the departure time, and we had to play musical chairs on the way. Once there, we doubled down on the rocky start with an Airbnb without hot water and a less than ideal layout, but we moved to a hotel and from then on had a great time. For some reason, I took a lot of vertical shots there.

🎬 90s Movies Were Always About Reality Control—Now We Really Get It

James Carr — Sun, 23 Nov 2025 02:00:00 GMT

My kids have been deep into a 90s-movie phase lately — which is surreal because these were my high-school movies and now apparently they’re “vintage.” So we’ve been watching The Truman Show, Dark City, and The Matrix together. The themes in these movies always felt familiar — identity, perception, reality, control. None of that is new. But watching them again today, after decades of living inside social media algorithms, and with a head full of Jung from a college philosophy class I once took (plus a recent binge of Jungian podcasts), those same themes land differently now.

Python Certifi and custom CAs

zufallsheld — Sat, 22 Nov 2025 21:00:00 GMT

At my last project, I wrote a small Python utility program to create and delete secrets in Hashicorp Vault. This tool was executed inside a docker container (and the container ran in a CI-pipeline). The container also talked to some other services that use an internal CA that was …

Does Dioxus spark joy?

fasterthanli.me — Sat, 22 Nov 2025 20:30:00 GMT

Note: this article is adapted from a presentation I gave at a Rust Paris Meetup — that’s why it sounds a little different than usual. Enjoy!

Good evening! Tonight, I will attempt to answer the question: Does Dioxus spark joy? Or at the very least, whimsy.

What’s Dioxus, you ask? It is first and foremost a name that is quote: “legally not inspired by any Pokémon”.

Even if the author concedes in a Hacker News comment that the “Deoxys” Pokémon is, I quote: “awesome”.

Lumina

Eleanor on Everything — Sat, 22 Nov 2025 14:29:42 GMT

A Logical Language for an Illogical World

People who no longer read as much as they used to

Nicola Iarocci — Sat, 22 Nov 2025 10:42:44 GMT

The theory that people no longer read as much as they used to is put forward by people who no longer read as much as they used to.

– Francesco Farabegoli

PyTorch Fundamentals - Week 4

Playground — Sat, 22 Nov 2025 02:00:00 GMT

Brushing up on my PyTorch skills every week. Starting from scratch. Not in a hurry. The goal is to follow along TorchLeet and go up to karpathy/nanoGPT or karpathy/nanochat. Previously,

Curl and jq go to a conference

Nicola Iarocci — Fri, 21 Nov 2025 17:57:44 GMT

I’m presenting at the WPC 2025 Conference on December 3rd in Milan. My session topic is Feature Flag Management and Dynamic Configurations in C#.

I will use a Web API as an example project, and since I’ll be using curl live to query it, I’ll need to pipe responses through jq to obtain nicely formatted JSON for the audience.

The problem with jq is that it crashes on 400s or 500s because the response body is empty in those cases. Error responses are inherent to the demo, and crashes are not the most desirable thing during a presentation.

Migrating from Ingress NGINX to Envoy Gateway

Michael van Tricht — Fri, 21 Nov 2025 16:51:15 GMT

I have been using Ingress NGINX since early 2021 and have always enjoyed working with it. With it being retired and only receiving updates until March 2026, I decided it was a good time to explore alternatives. This is my short journey of searching for a replacement.

My current ingress-nginx setup is fairly straightforward. A set of standard ingress rules and a wildcard SSL certificate managed by cert-manager. Nothing too unusual except that the wildcard certificate is a default certificate and none of the ingresses reference a certificate.

La Niña

Nicola Iarocci — Fri, 21 Nov 2025 11:02:29 GMT

Last night we went to Bologna¹ to see La Niña in concert, a birthday present from the kids to Serena. She loves this artist, whom I didn’t really know before last night. The concert was very nice, even though, not knowing her, I was initially confused, I think by the local folk festival atmosphere, if such a thing exists. It took me a few minutes to understand what I was looking at and what I was listening to.

SaaS keywords by Search Intent or Funnel Stage

Bhupal's Web Page — Fri, 21 Nov 2025 10:47:31 GMT

When people ask for a “top 100 SaaS keywords” list, they are usually looking for a shortcut to SEO success. In reality, such a list is not very practical.The most valuable SaaS keywords are highly dependent on what your product does — whether it’s CRM, project management, accounting, email marketing, analytics, or something else entirely.A […]

Inexorable Progress

Separate Concerns — Fri, 21 Nov 2025 10:40:00 GMT

I live in France, I work on AI, and I am worried.

I believe that technical progress is inexorable in a globalized world. If a scientist makes a discovery and does not disclose it, another will make the same one within a few years. If a company forgoes a major innovation it will be disrupted by competitors that adopt it.

This makes research and innovation a game — in the game theory sense — in which not participating is not an option. You cannot stop the flow of progress, you can only decide to be an innovator, an early adopter or a laggard. You either lead or you endure.

Whether you like it or not the current AI wave will cause seismic changes. It is time to revisit 1970s science fiction because we are about to live in those worlds. And by their nature, some of these advances are likely to be winner-take-all.

Dropping out of the race for ethical or social reasons is short-sighted. It is very likely that whether the end result is good or not the first to reach these milestones will benefit immensely and strengthen their ability to influence the future. If you slow down, you are simply letting those who do not care about these issues in the first place win.

The French political leadership and that of Europe have a well-known track record of hindering innovation through regulation. We are the poster child for the precautionary principle. In addition to that, we currently face political unrest and our public opinion is easily swayed against anything new or successful.

The EU Commission has apparently noticed the problem. They are doing things, but it is too little too late. At the current pace, the goal should not be to let our industry do the things the US and China were doing five years ago.

I live in France, I work on AI, and I am worried. Maybe you should be too.

Token Efficiency

june.kim — Fri, 21 Nov 2025 02:00:00 GMT

We should all be using dependency cooldowns

ENOSUCHBLOG — Fri, 21 Nov 2025 02:00:00 GMT

TL;DR: Dependency cooldowns are a free, easy, and incredibly effective way to mitigate the large majority of open source supply chain attacks. More individual projects should apply cooldowns (via tools like Dependabot and Renovate) to their dependencies, and packaging ecosystems should invest in first-class support for cooldowns directly in their package managers.

Use slog.LogValuer interface

Paul's page — Fri, 21 Nov 2025 02:00:00 GMT

log/slog is no longer new in Go. It was introduced in 2023 with Go 1.21. But it is very nice for structural logging. Here’s how to make that structural logging work better for you:

Fixing the RP2350-USB-A not working as USB host

Quentin Santos — Fri, 21 Nov 2025 01:36:55 GMT

tl;dr: you need to desolder R13, the resistor closest the pin 6 of the board, as indicated by the red arrow in the cover picture of this article Context I am currently toying around with emulating a USB device. However, I also wanted to be able to plug a keyboard in, so I needed a […]

The post Fixing the RP2350-USB-A not working as USB host appeared first on Quentin Santos.

Reflections on The Curve

Second Thoughts — Thu, 20 Nov 2025 20:44:23 GMT

A compilation

Principles of Economics Made Clear (Part 3)

Photon-Lines Substack — Thu, 20 Nov 2025 16:42:26 GMT

Part 3 of the Principles of Economics Made Clear series.

Building a Durable Execution Engine With SQLite

Gunnar Morling — Thu, 20 Nov 2025 14:10:00 GMT

Table of Contents

Hello Persistasaurus!
Capturing Execution State
Delayed Executions
Human Interaction
Managing State
Wrapping Up

Lately, there has been a lot of excitement around Durable Execution (DE) engines. The basic idea of DE is to take (potentially long-running) multi-step workflows, such as processing a purchase order or a user sign-up, and make their individual steps persistent. If a flow gets interrupted while running, for instance due to a machine failure, the DE engine can resume it from the last successfully executed step and drive it to completion.

Private Equity 101 for the tech industry

João Alves — Thu, 20 Nov 2025 12:09:19 GMT

Note: I’ve translated this article into Spanish on November 20th, 2025. Because this is a long read, you can find the article in the “Desde mi terminal” newsletter.

Imagine this: you're working hard in your tech company, perhaps building a cool new feature or keeping the infrastructure humming, and then word comes down that your company is being acquired, not by another tech giant but by a private equity firm.

This can feel like a sudden shift if you're like many, perhaps raising more questions than answers. What exactly is private equity (PE), what does a buyout mean, and what might happen next for the company and you?

Let me share my experiences, alongside insights from others who have been through this transition, to help clarify this new landscape.

What exactly is Private Equity?

At its core, private equity involves investment companies buying entire businesses, often taking them private if they were previously publicly traded.

Their main objective is to increase the company's value, typically over five to seven years, and then sell it for a profit.

Unlike venture capital firms that fund young startups, PE firms target more mature companies. A standard method is a Leveraged Buyout (LBO), which uses a large portion of borrowed money (debt) alongside equity to fund the acquisition. Think of it like a mortgage: the firm puts down equity, and a loan covers the rest, secured by the company's assets and future cash flows.

While this approach can amplify returns, it also adds risk, since the company must repay the loans regardless of market conditions.

Why Tech? Why Saas?

PE firms love Software-as-a-Service (SaaS) because these businesses often have:

High gross margins
Predictable, recurring revenue streams
Low capital expenditure once scaled

These traits make them resilient and great at generating cash. A stable SaaS company with loyal customers is an ideal LBO target.

Recent market dynamics

Over the past few years, broader macroeconomic shifts have reshaped the private equity landscape, particularly in tech. The easy-money era that fueled sky-high valuations gave way to inflation concerns, rising interest rates, and a renewed focus on fundamentals. This reset created a unique environment where PE firms saw opportunity in companies struggling to adapt. Here’s how that played out:

ZIRP-era boom and bust: Tech valuations peaked around 2020–2021 due to the zero-interest-rate policy (ZIRP), then fell sharply as markets refocused on profitability.
Buying opportunity: PE firms moved in to acquire undervalued assets, especially companies struggling to shift to capital efficiency.
Profitability focus: PE firms prioritize efficiency and profitability over rapid growth.
More extended hold periods: With IPOs tougher in 2022–2025, exits have been delayed, leading to longer ownership timelines.

The PE Playbook: How value is created

After acquisition, PE firms implement a Value Creation Plan (VCP) that typically includes:

Debt paydown (deleveraging): using company cash flow to reduce acquisition debt.
Operational improvements: cutting costs and improving profitability.
Multiple expansion: selling the company at a higher earnings or revenue multiple.

There are a few common changes or signals you might see.

Cost cutting

Private equity firms almost always begin with a round of cost-cutting. This typically includes:

Layoffs, often in the range of 10–30%, particularly in overlapping or non-essential departments. For instance, after Thoma Bravo acquired Anaplan for over $10 billion in 2022, more than 300 employees were laid off within a year.
Discretionary spending cuts include reduced travel, entertainment, vendor spending, and budgetary tightening across teams.
Office consolidations or transitions to remote-first operations to reduce real estate costs.

New leadership, with a focus on three key roles

After a private equity buyout, one of the earliest and most visible shifts is often leadership and organizational alignment. PE-owned boards may replace existing leadership or give them narrower mandates, especially if they are seen as too "growth-first," lack operational discipline, or are culturally misaligned with the PE firm's priorities. In particular, three roles are almost always scrutinized:

The CEO is often the first role reviewed because they set the company's strategic direction and cultural tone. In many cases, CEOs coming from a venture-backed or "growth at all costs" environment may not be well-suited to lead in a PE-owned context, where value creation is tied more to free cash flow, operational efficiency, and exit planning. If a CEO resists a shift from rapid expansion to profit-driven scaling, or lacks experience leading through that kind of transition, PE firms may replace them with someone with a proven track record of executing turnaround strategies or successful exits. PEs expect the new CEO to lead urgently, drive accountability, and deliver against a well-defined value creation plan.
The CFO becomes a pivotal figure under PE ownership, responsible for financial oversight and managing the company's ability to generate and retain cash. While earnings before interest, taxes, depreciation, and amortization (EBITDA) remains an important benchmark, PE firms prioritize free cash flow (FCF) as the actual performance measure since it is the cash that services debt and enables reinvestment. A CFO without strong experience in forecasting, liquidity planning, working capital management, or debt covenant navigation may be replaced with someone from a private equity, corporate finance, or investment banking background. The ideal CFO under PE can build clear dashboards, track return on investment (ROI) by segment, and help optimize capital structure to maximize returns.
The Chief Human Resources Officer (CHRO) plays a critical role in enabling the organizational and cultural transformation that PE firms require. Often underemphasized in earlier-stage companies, this role becomes essential during post-acquisition transitions. The CEO/board typically tasks the CHRO with executing cost-cutting measures such as reorganizations or layoffs and redesigning compensation structures to align incentives with new financial KPIs. They also help shift the culture toward high performance, accountability, and transparency. CHROs often implement clearer performance management frameworks and career progression tied to business outcomes. A CHRO focusing more on long-term culture building or employee experience at the expense of operational alignment may be seen as a poor fit for the PE stage.

New KPIs

KPI focus shifts from growth metrics (like Monthly Active Users or Revenue Growth Rate) to profitability indicators like:

Gross margin
EBITDA
Customer Lifetime Value (LTV)
Customer Acquisition Cost (CAC) payback period
Rule of 40 (Revenue growth % + Profit margin % >= 40)

You can expect frequent reporting cycles and dashboarding around these metrics, with performance tied to bonus or equity incentives.

Price and revenue optimization

PE firms often believe companies are undercharging or leaving money on the table. With a focus on increasing revenue without increasing customer acquisition costs, PE firms encourage:

Price increases across key products or services, sometimes subtly implemented with:
- Fewer discounts or promotions
- Annual contracts replacing monthly billing
- Price hikes bundled with "value-add" features (e.g., "you pay more but you also get more").
Upselling to higher tiers or more feature-rich plans
Cross-selling complementary products or services from within the portfolio or via bundled offerings
Sales and customer success teams are often given new incentives and quotas tied to wallet expansion

Product rationalization

Research and Development (R&D) spending typically comes under the microscope post-acquisition. Management teams:

Often cut experimental or long-horizon projects, especially those with unclear ROI or distant commercialization timelines.
Reallocate investment to high-margin, proven products with known customer demand.
Shift roadmaps from innovation to stabilization, focusing on performance, reliability, and monetization.

While this boosts profitability, it can slow innovation and lead to internal frustration for product and engineering teams used to a more experimental environment.

The hard truth: Cash flow > EBITDA

While EBITDA is a widely used metric to understand a company's financials, free cash flow (FCF) is arguably more important for private equity firms because it reflects actual cash available to service debt, reinvest, or return to investors. Why do PEs love free cash flow?

Debt Service: The company takes on substantial debt in a leveraged buyout. FCF is what repays that debt, not EBITDA. If a company has strong EBITDA but poor FCF (due to high capital expenditure [CapEx] or working capital needs), it may struggle to service loans
Predictability: High-quality tech/SaaS companies often convert EBITDA to FCF at high rates due to low CapEx needs. That makes them ideal for leveraged deals and easier to manage under PE ownership.
Valuation and exit planning: PE buyers and future acquirers (or IPO investors) often value companies based on FCF multiples, not just EBITDA, especially in mature companies where growth has slowed.
Cash distributions/returns: FCF allows private equity owners to:
1. Deleverage quickly.
2. Pay themselves dividends (dividend recaps).
3. Reinvest in bolt-on acquisitions.

Real example of when EBITDA is misleading

Imagine a mid-sized SaaS company with a $50 million EBITDA. Sounds great, right? But now look at what's eating into that:

Capital expenditures (CapEx): $20 million, because they run their own data centres and bought a ton of GPUs from NVIDIA.
Working capital drag: $15 million. Sales are growing, but customers are paying late. Therefore, cash is tied up.
Taxes: $5 million

So while the profit and loss statement (P&L) might look strong, the business is only throwing off $10M of usable cash. That's the number PE firms care about most. It determines whether debt gets paid off, whether bonuses get paid, and whether the exit plan stays on track. That is why, under PE ownership, the CFO and leadership team become laser-focused on FCF: cutting unnecessary spend, shortening payment cycles, and delaying CapEx unless it has a clear ROI. Because cash, not paper profit, is what keeps the deal alive.

What does it mean for me, as a tech professional?

1. Change is faster than ever

Once a PE firm takes over, decisions that used to take months may now take days or weeks. Speed is part of the playbook: the new owners quickly implement org restructures, re-prioritizations, and budget shifts to hit value creation targets. You may find:

Projects were canceled or accelerated with little notice.
Reorgs that change your manager or team structure overnight.
Roles are evolving to match new priorities (e.g., shifting from R&D to product monetization).

Tip: anchor yourself to initiatives aligned with profitability, customer retention, or core product success. You'll be in a stronger spot if you lead or contribute to projects that generate revenue or reduce costs.

2. Operational discipline

The cultural shift can feel jarring if you're used to a "move fast and break things" environment. PE firms typically instill a more structured, ROI-driven operating model:

Budget approvals may now require detailed business cases and ROI models.
Finance people may ask every team to justify their expenses, headcount, or initiatives.
Tools like OKRs or KPI dashboards become standard, with a clear link between individual contributions and company-level metrics.

The upside? Less chaos and clearer priorities. The downside? Less tolerance for ambiguity or experimentation without results.

3. Career and compensation

Your total compensation package may shift:

Career progression may become more structured and tighter. Promotions are often more directly tied to measurable business impact. Advancement may slow if you can't connect your role to cost savings, revenue growth, or efficiency.
Performance reviews also tend to become more rigorous, with regular check-ins against specific KPIs and a higher bar for continued advancement.
You'll get exposure to rigorous business fundamentals, from cash flow modeling to unit economics to board-level performance reviews.
Many PE firms bring in seasoned operators, advisors, and board members, offering mentorship and networking opportunities.
Base pay might remain good, but variable compensation (bonuses, equity) may now be tied to EBITDA, Free Cash Flow, or other financial milestones.
Some employees may be granted new equity, typically under long-term incentive plans that align with the PE firm's exit strategy (e.g., sale or IPO).

This can feel like a significant cultural shift, especially if you came from a high-growth startup with broad roles and informal promotion paths. That said, top performers tend to thrive under this system. In particular, those who enjoy accountability, clarity, and a tangible connection to company performance.

The PE phase can be professionally and financially rewarding if you're analytically minded, execution-driven, and adaptable.

Final Thoughts

Private equity's growing presence in tech marks a new era. The days of free capital are over. PE firms are betting on undervalued companies and using financial and operational rigor to extract value.

Understanding this shift from high growth to high efficiency and staying adaptable can help you navigate the changes ahead. Have you experienced a PE buyout? How did it go?

— João

I’m building RotaHog, a lightweight tool for managing team rotation schedules (on-call, support shifts, release duties, etc.). Try it if you're tired of hacking spreadsheets or Slack threads together. I’d love your feedback!

If you enjoyed this article, consider subscribing to the newsletter and buying me a coffee.

Fixing kernel updates not applying in Fedora 43

nyanpasu64's blog — Thu, 20 Nov 2025 08:30:00 GMT

One of the stranger issues you can encounter on Fedora is when new kernels stop being bootable from the GRUB bootloader. This usually happens after major version updates, and has been reported online from Fedora 39 up to the present day. In my case kernels were being installed to /boot/efi rather than /boot, where GRUB expects kernels to be placed. In the process of fixing this issue, I learned about how Fedora and kernel-install determine where to place boot entries.

Introducing pkgstore.io

mfkl — Thu, 20 Nov 2025 06:10:40 GMT

A curated directory of commercially backed .NET packages — making discovery easier for developers and sustainable for publishers.

Neutral Tone

june.kim — Thu, 20 Nov 2025 02:00:00 GMT

Halo World Championship 2025

Den Delimarsky — Thu, 20 Nov 2025 02:00:00 GMT

The family tradition of attending every Halo World Championship continued in 2025, an extra special year because of the last HCS installment on top of Halo Infinite.

210 IQ is not enough

taylor.town — Thu, 20 Nov 2025 02:00:00 GMT

You will never have enough IQ, nor money, nor time, nor energy.

Three AI Agents Walk Into a Bar (and Only One Actually Read the Menu)

Prasham H Trivedi — Thu, 20 Nov 2025 02:00:00 GMT

I tested three AI coding agents on writing analysis-Claude, Gemini, and Codex. After fixing a configuration bug, the results changed dramatically. Here’s what happened.

Things I learned as an Airbnb host 2021-2022

Michael Ian Lewis — Thu, 20 Nov 2025 02:00:00 GMT

Introduction Link to heading

This post summarises the things I learned while I was an Airbnb host between Nov 2021 and Dec 2022. I did the short lets for my old flat in Shoreditch as an alternative to leaving the property vacant while I was trying to sell it.

It has taken until now to publish the post, because I wanted to complete the sale first (and therefore be sure I wouldn’t relist on Airbnb), but encountered various issues, e.g. Covid, a sale falling through during the September 2022 mini-budget economic crisis and falling victim to estate agent fraud¹. I know many things have changed in the short let space since 2022, but I think some points will still be relevant and potentially useful.

Typst for Your Code Blocks

Lambda Land — Thu, 20 Nov 2025 02:00:00 GMT

I started using Typst about a month ago to write my dissertation proposal. I had seen Typst before and decided to keep an eye on it as it matured. While it still is very much in development, it is mature enough that I was able to rewrite my dissertation proposal from an org-mode → LaTeX pipeline to pure Typst in about an hour with no major hiccups. In fact, most things got simpler as a consequence of using Typst.

Typst is a typesetting system written in Rust designed to be a replacement for LaTeX. LaTeX is the de-facto standard for typesetting technical documents thanks to its unsurpassed support for rendering mathematical formulae and its attention to excellent typography. Both LaTeX and Typst operate by transforming a markup language into an output format like PDF.

I am working on a presentation to give as part of my oral defense of my dissertation proposal. (Note: I am not defending my dissertation yet—first I have to justify my plan of research to my PhD committee.) I found a way to use Typst to get gorgeous source code blocks at minimal cost.

Classic ways to get syntax highlighting

I like having good syntax highlighting in my technical presentations, but getting properly highlighted code was either shoddy or labor-intensive. The tradeoff is:

Good-quality source code: I have often typed the source code into my slide and then manually highlighted each word the appropriate color. This is pretty time-consuming, but it has the best results since the font can be scaled as large as I want, and I can manipulate the text as I see fit. Having things like a pre-defined color palette in my color picker and selecting non-contiguous regions with ⌘-click: I can select all keywords and highlight them with the color I want.
Quick screenshots: Of course, taking a screenshot of an IDE is always an option. This is nice because you don’t have to spend any time manually highlighting each word. The downside is that it’s fundamentally a pixellated image and that becomes evident as you scale the picture.

I will still be using the highlight-each-word technique when I need to show some code and simulate editing it; the “Magic Move” transition in Keynote makes these kinds of code-editing demos easy to build and easy for the audience to follow. However, the majority of the time I’m just displaying code on the screen.

Typst to the rescue

I built a Typst template and associated theme file for code blocks. Now, if I have some code I want to put on a slide, I write a Typst file like the following and put into e.g. example.typ:

#import "code_template.typ": conf
#show: conf.with(cols: 92)


```elixir
# Receive from the client <- client_proof
valid? = SRP.valid_client_proof?(client_proof, password_verifier,
                                 server_key_pair, client_public_key)

if valid? do
  # Send back to client the server's proof -> server_proof
else
  # Send back unauthorized
end
```

Then I run typst compile example.typ and I get a PDF file with a transparent background that looks like this:

(That’s obviously a PNG file so that it displays nicely here on the web. The real output of that command is a PDF file.)

I can take that PDF file with a transparent background and drop it straight into my Keynote presentation. Typst takes care of all the syntax highlighting and it’s been good enough for my needs.

I am really excited about Typst

Typst is still pretty new software. It has some rough edges and I will not be asking conferences to support Typst for their submissions until all those corners have been smoothed out. However, I am hopeful for Typst’s future, and anywhere where I can get away with just submitting a PDF without the source, I will be using Typst.

The things that Typst does better than LaTeX right now:

Incredibly friendly syntax and rendering model. I went from not knowing anything about Typst to reproducing my résumé perfectly in an hour. I even made use of fancy things like functions.
Excellent documentation. Did I mention how quickly I learned how to use Typst? It is easy to find the thing you want to customize.
Instantaneous build times. Anyone who works with LaTeX will be familiar with 20+ second build times. Typst is so fast that it can live-rerender documents multiple times a second.

Typst has good typography and bibliography support. It can work with BibLaTeX .bib files, so you can start using Typst without having to rewrite your whole bibliography. Citation syntax is simple and easy to figure out.

Typst sill has a bit of a way to go before it does everything that the venerable LaTeX Microtype package does, but it’s making progress in this area.

Typst is free and open-source; you can contribute on their GitHub repository. It’s written in Rust and the code seems to be well-organized. They have a hosted collaboration platform that is proprietary; you can subscribe to this, and the funds spent here go towards paying a few full-time developers to work on both the closed-source collaboration platform and improving the open-source compiler. I think this is a neat model and I hope it lets Typst get off the ground and get the adoption it will need to survive and (hopefully!) supplant LaTeX as the typesetting system of choice for technical audiences.

Moving Beyond the NPM elliptic Package

Dhole Moments — Thu, 20 Nov 2025 01:49:20 GMT

Why replace the elliptic package? Yesterday, the Trail of Bits blog published a post about finding cryptographic bugs in the elliptic library (a Javascript package on NPM) by using Wycheproof. This blog post was accompanied by a new chapter in their Testing Handbook about using Wycheproof as well as two CVEs. It’s pretty cool work, […]

Hyperproductivity: The Next Stage of AI?

Second Thoughts — Thu, 20 Nov 2025 01:42:01 GMT

A glimpse at an astonishing, exhilarating, exhausting new style of work

Moving to Pika from Ghost

Notes from the Burrow — Thu, 20 Nov 2025 01:26:17 GMT

I’ve been debating if I should move over to Pika after finding out about last week. I really like the simplicity and the ease of use compared to Ghost. In...

How the Linux-vs-BSD culture clash looked in the 1980s/1990s

Liam on Linux — Thu, 20 Nov 2025 01:09:42 GMT

(Repurposed HN comment.)

The BSD/Linux thing was there right from the start, but it was more complicated than a simple us-vs-them. The thing is that there were a whole bunch of competing commercial Unix-like OSes in the 1980s.

But there were other prejudices as well.

In Proper Grown-Up Unix terms, PCs were toys, poorly-made weird little things that were no more than office equipment. So nothing worth using ran on the 386.

There was no local bus yet, no IDE or EIDE, slow AT expansion bus, no processor cache, and so on -- meaning a forest of proprietary or semi-proprietary extensions and buses and special slots. This opened up a market for a vendor to port to Brand X PCs and Brand X's own weird storage and display.

Enter Interactive Corp, which tried to combat this, and worked on Unix ports for various vendors' hardware. Expensive OS for expensive machines.

And there was SCO which wasn't proud, wasn't fancy, ran on commodity kit, and didn't try to be a general purpose OS like that white lab-coat brigade expected. So SCO Xenix worked, and you could run apps on it, but in the box there was no C compiler, no networking, no X11, nothing. It was a runtime-only OS and it was still expensive.

Everyone sneered at it but it did the job. I put in a lot of it.

Then if you weren't paying, someone else was who would never see the word "Unix", there were all the vastly expensive RISC boxes with their vastly expensive expansions and vastly expensive -- well, everything. Sun, HP, DEC, IBM, SGI, loads of company would sell you rooms full of workstations, single-user minicomputers with big screens. They cost as much as a house.

Actual BSD ran on actual minicomputers that cost as much as a small street of houses and those dudes wouldn't even look at PCs.

Which left a market for enterprising vendors squeezing Unix-like things onto low end kit.

Various flavours of BSD, including BSD/OS; SCO Xenix in both 286 and 386 versions; Interactive 386ix; several vendors' own-brand licensed Unixes, including Dell, later, an official Intel one that mainly ran on Intel's own pizza-box workstations.

And all the proprietary computer vendors entered the game too. Commodore did Unix for high-end Amigas; Atari did Unix for high-end STs; Acorn did Unix for high-end Archimedes; Apple did Unix for high-end Macs, allegedly originally just to get a US military deal; etc. etc.

All these are still $1000 per instance OSes though.

Then, universally scorned, MWC Coherent, a real Unix-like OS for $99... and QNX, which was apparently good but mainly focused on real-time stuff, and cost more than the casual could afford.

(As a European I never saw this but it was in all the ads in all the US mags. There was a lot of "cheap" American stuff we didn't get over here, like paid-for shareware. We had metered phone calls so no BBS scene. Only rich Americans got that stuff.)

Coherent was so good that AT&T accused them of theft and sent Dennis Ritchie around to check. He came back and said, no, it's legit.

And Andy Tanenbaum's Minix, a toy for students, not for real work, but essentially free with a book.

These latter indirectly showed that you _could_ copy AT&T's holy grail and make it work, so while Richard Stallman was building all the tools but choosing the wrong kernel and sabotaging the whole thing, along came this Finnish kid with his learning exercise, and excited beardies on Usenet said that it actually worked and it was at least as good as Minix and was getting to Coherent levels.

So the point is, there was a spectrum, from legendary machines made from purest unobtainium, to ludicrously expensive x86 stuff for very specific (and ludicrously expensive models) of PC kit, to the still ludicrously expensive SCO that got no respect, to "cheap" stuff that nobody had in Europe because it had no business purpose. There was legendary free stuff in America but it only ran on room sized computers that cost as much as a lottery win, so I never saw it. "Free" as in "it's free if you're so rich it doesn't matter."

And "free" shareware that was "free" as in "the phone bill to get it will cost more than just buying a commercial version in a shiny box".

But there _was_ a spectrum, from vastly expensive to "a small business will pay for this", down to theoretical stuff in America that you could dream about... which paved the way until the point where an ordinary PC was a 32-bit machine with a memory management unit and hundreds of megs of disk and several megs of RAM, and suddenly, this Lin-Min-Gnu-ix thing was doable, if you had a beard and a checked shirt with black jeans and wore hiking boots every day.

comments

Why the public cloud is going nowhere

Zaq Labs Product Blog — Thu, 20 Nov 2025 00:20:17 GMT

From my experience dealing with infrastructure

Reviewing The Strength of the Few by James Islington

Davis Haupt's Blog — Wed, 19 Nov 2025 19:00:00 GMT

This is a tough sequel to review without any spoilers for The Will of the Many, so I’m not going to attempt it. Spoiler warning for Book I below!

The Strength of the Few picks up right where The Will of the Many left off: Vis, the protagonist, has been simultaneously copied into two other worlds called Luceum and Obiteum while his story also continues back in the world of Book I, called Res. Somewhat necessarily, each storyline is not as deep as the story in the first book.

The politics and motivations that made me excited about The Will of the Many fade into the background of this installment. The Catenan Senate in Res is relegated to a third of the chapters, and Vis’s unfamiliarity with the other two worlds make him much less of an astute observer of the political machinations around him there.

I mentioned in my last review that the world of Res felt shallow for how physically large it was. I can better forgive some of that that shallowness here considering how different Obiteum and Luceum feel. The Strength of the Few shows that Islington can build deep history and culture into his worlds when he wants to, but he sometimes thinks its better to keep readers at an information disadvantage for the sake of the plot.

Luceum

I absolutely loved the Luceum storyline. Readers are introduced to an entirely new world with just enough detail to keep us engaged and excited to learn more without overwhelming us with exposition. The way Islington uses Gaelic to represent Luceum’s primary language is great. From most readers’ perspective it’s the same as if he’s made up his own language without needing to be a philologist on top of being a fantasy author.

The worldbuilding in Luceum felt much more like what Ursula K. Le Guin utilizes in her Earthsea books rather than the exposition-heavy information dumps that Islington uses elsewhere that reminds me more of The Broken Earth Trilogy’s latter entries.

This version of Vis also has some real character growth here in a way that was completely missing in Obiteum and unsatisfying in Res.

Obiteum

Obiteum reminded me of Cittagazze from The Subtle Knife: the world is clearly broken, and something related to the existence of multiple worlds was what broke it. In general I saw more influences from His Dark Materials than Red Rising throughout The Strength of the Few. The initial imagery of Gleaners parallel Spectres in a very fun way.

Once we move from the rebel hideout of Qabr into the city of Duat, though, things start to fall through the cracks. My book club all agreed that we needed a map of Duat to go along with Vis’s descriptions of how he is moving through the city. I would love to have learned more about the society in Duat, its religion, and the totality of how Will works in Obiteum. So much time is spent on the undead Iunctii, but Vis’s entrance to Obiteum introduces us to a variety of Will-based devices that aren’t mentioned at all in parts II and III.

Res

I enjoyed learning more about the mechanics of Will and how Catenan society operates outside the confines of the Academy. Vis is fully on the inside of “the system” now, and seeing how Will affects everything from politics to athletics to combat was great.

The Catenan civil war completely changes the setting and unfortunately as much as we spent learning about Catenan politics in Book I and the first half of Book II, there’s so many more forgettable Catenan senators introduced whose motivations are explained mostly through exposition dumps.

All in, Part III’s Res storyline felt very rushed. Vis makes some consequential decisions which feel like they come out of nowhere. A new plan from Vis and Eidhin in the final 100 pages which I assumed would form the Res plotline in Book III is somehow wrapped up in less than a chapter. While there are strong emotional points, I ultimately don’t truly understand why Vis makes the decisions and alliances he does.

Splitting the Book

There were two very disorienting time jumps in the book: 6 weeks in Obiteum between parts I and II, and a month in Res between parts II and III. The narration refers to events and people that happened in the meantime without any indication of missing chapters in between — both times I had to double-check that my Kindle didn’t glitch out and miss a few dozen pages. Ultimately I think the location of these time jumps mark out a good place where the book itself could have been split in two:

Book II would follow the entire Luceum storyline, Vis’s time in Qabr in Obiteum, and the Res storyline up until Excesius is killed. This can dive more deeply into how exactly Will is used in Caten and flesh out the politics of the Senate even more.

Book III would cover the Catenan civil war and Vis’s infiltration of the city of Duat in Obiteum.

The downside of this approach would be that the three storylines would not proceed in lockstep in time. Maybe Islington is planning some bigger payoff in the next book, but there was one moment of “synchronism” that did not feel narratively or emotionally powerful, so I don’t think the parallel narrative gimmick is particularly worth it.

Conclusion

Overall I enjoyed learning more about the world(s) that Islington is building. My excitement about Luceum mostly counterbalances my confusion in Obiteum and my frustration with how Res feels even smaller and more condensed than in the first book.

Backstory isn’t bad in and of itself, but learning more history shouldn’t be the reason we keep reading. I don’t like when characters (and readers) learning new information becomes the main plot tension in a story. When revealed, the “right” answers are often not as satisfying as the possibilities and theories that readers come up with along the way. Right now I don’t know what’s a plot hole and what’s a conscious omission that will be filled in later to support a twist or some other dramatic effect. The only way to find out is to wait for the rest of the series to be published.

The Expanse balanced this well: its final installment gave some satisfying answers about the Protomolecule while leaving enough to interpretation and keeping the conclusion of the book mostly about the characters we’d gotten to know.

Considering how the focus of The Strength of the Few shifted from the motivations of individual people and groups in Res to the cosmic forces connecting and separating the three worlds we’re now following, I’m not as optimistic that Islington will stick the landing.

The Role Bridging Problem

smcleod.net — Wed, 19 Nov 2025 17:10:00 GMT

An observation on functional correctness without domain quality.

How I Designed a "Perfection" Template

Wigs on the Green — Wed, 19 Nov 2025 17:00:36 GMT

The template went pretty far in the Fried Egg design contest, so I thought I would share how I threw it together in a few hours.

Do Less

Sunil Shenoy — Wed, 19 Nov 2025 03:54:15 GMT

Since I moved back to India in 2009, I have struggled with managing my calendar. There were more things to do than I had time for. There was always that one new project to work on.

The last few years though, I made a conscious decision to slow down. Do less. Work less. Spend more time doing nothing. It was a long process of slowly parting ways with projects I had worked on for ten-plus years. As much as I enjoyed working with the team and on the product, I told myself I should be doing less. Do less instantly became a mantra.

Do less to do what though? I never asked myself that question. “It’s a question I answer later,” I told myself, because I was not sure if I would ever get to now. I am glad I did not answer the question then and pressure myself to do five new things to replace the previous things I committed to.

I have been doing random things with my free time: reading more, walking more, listening to more podcasts, working on an app that I have been wanting to work on. None of these take as much time, and it’s been great. Do less. I would highly recommend it if you can afford to. Being bored has been great.

Digdoku

Kevin Cox's Blog — Wed, 19 Nov 2025 03:45:00 GMT

I randomly had the idea that it would be interesting to “dig into” all possible Sudoku puzzles. So I created Digdoku. The landing page is an “empty” puzzle, each link leads to a puzzle with one additional square filled. Values that are not possible are excluded. So you can never get an invalid puzzle by clicking links (but you can by editing the URL).

The concept is simple. Basically for every unset cell it attempts to solve the puzzle with every number from 1-9. If any solution is found that value is possible, otherwise it is omitted.

This “eager” removal of impossible values means that it functions as a solver as well. By the time you click all of the provided squares (or often sooner) there will be only one possible grid, and it will be revealed.

However, implementing this simple solution is fairly slow. So some optimizations were necessary. These are primarily around skipping options that are easily determined to be impossible or were already found to be possible. The solver is still mostly a brute-force depth-first solver with some very basic rules put on top (such as eliminating duplicate values in a box/column/row group and if a value can only be in one place as a group it must be that).

The slowest case I am aware of takes about 100ms on my desktop. It could almost certainly be much faster, I suspect another order of magnitude would be fairly easy to achieve. But in the first version some cases took over six minutes, so I’m calling it good enough for now.

One downside is that the URL only keeps minimal state, so a lot of options need to be re-eliminated every step of the way. Maybe compiling to WASM and running an incremental solve client-side would be better. Might be something interesting to try. It would also avoid the risk that my single-core VPS gets overloaded if this gets popular. I do have caching enabled, but I suspect after a few clicks hits will become quite rare.

There is also something about a simple HTML response that I am very fond of. Theoretically you could pre-render every possible grid into a static site. But according to Wikipedia there are 6.6e27 valid Sudoku grids, so I’ll hold off on the pre-render for now.

The Tension

Ben Bolte — Wed, 19 Nov 2025 02:00:00 GMT

Stream-of-thought writing about tension.

Building a Minimal Viable Armv7 Emulator from Scratch

xnacly - blog — Wed, 19 Nov 2025 02:00:00 GMT

Emulating armv7 is surprisingly easy, even from scratch AND in Rust

against apologising

cjlm.ca — Wed, 19 Nov 2025 02:00:00 GMT

Writing on the internet is risky as it increases your attack surface for criticism. If you don’t write anything you’re not a target. If you write something it’s guaranteed that someone will have something to say about it.

Pre-empting this criticism hits your confidence and reduces the impact of your writing. Good writers have a voice, a recognisable way of seeing the world and sharing their thoughts. Less confident writers anticipate the loud voices of the "gotcha gang”, take up a defensive stance which seeps into their writing.

The best online writers don’t care about positive or negative discussions of their work, they understand that’s the trade-off with writing publicly. It’s on them to moderate their exposure and regulate their emotional response to the response.

It’s ironic that by trying to accommodate all readers the work is diminished; ignoring them improves it.

Grace Blackwell Desktop Supercomputer: First Impressions

Jason Eckert's Website and Blog — Wed, 19 Nov 2025 02:00:00 GMT

Earlier this year, NVIDIA caused quite a stir in the data-science community when they announced the DGX Spark: a desktop-sized AI supercomputer. It’s aimed at developers and data scientists who need to prototype, tune, and run AI models locally without constantly relying on expensive cloud hardware.

At the heart of the DGX Spark is the new GB10 chip, which combines NVIDIA’s 20-core Grace ARM CPU with the Blackwell GPU. Together, they deliver roughly 1 petaflop of AI compute and come paired with 128 GB of memory and 4 TB of fast local storage. The system ships with Ubuntu Linux 24.04, which immediately appealed to my inner UNIX/Linux fanatic.

Manuel was annoyed

Annoying Technology — Tue, 18 Nov 2025 21:07:48 GMT

Our corporate IT policy enforced the Tahoe upgrade on my work Macbook – now I’m getting these warnings when I connect it to my screen. I do so via a single USB-C connection for both display and power, and I’ve got half a dozen other devices (a webcam, my keyboard, the tiny amp for my mic, a Litra Glow, a Stream Deck…) connected through the integrated USB hub. Everything works as before, so why bother me with this?

Ice Cube: Truth to Power in Atlanta GA

The Digital Nomad — Tue, 18 Nov 2025 19:13:04 GMT

Our next concert of the year was Ice Cube. He said that his “Mic was live” the entire concert, meaning no backing track, no lip syncing, no call and response. just him rapping live the entire night except for his few collabs. It was definitely the best rap concert we have been to and ties with the Wutang Clan.

We stayed back at the Hyatt House. The concert was on a Tuesday. We stayed in Atlanta for five days to get a chance to spend time with our friends and to see our sons.

We fell in love with the Hyatt House after our last visit. It came in handy for longer stays where I had a separate room to work in without disturbing my wife.

justfiles can feel magical

hlfshell — Tue, 18 Nov 2025 19:09:31 GMT

I’ve long been a fan of task runners within projects - I find they’re practically required once you have a project or group operating beyond a certain level of complexity. There are just too many one liner terminal commands to memorize, too many differing syntaxes across dozens of tools operating across different stacks… it’s madness. Typically engineers (at least the ones that eventually give up on the muscle memory approach) combat it with either a host of bash scripts or Makefiles through tons of .

On drawing the line

bryce — Tue, 18 Nov 2025 18:30:00 GMT

I'm all for self-improvement. Investing the time to learn new things into adulthood has had a positive impact on my life, but everyone has a different threshold for the value add vs inconvenience.

This has been true in both my professional and personal life, from learning a new language to finding a new favorite recipe.

I draw the line however at changing how I tie my shoelaces. Once YouTube starts recommending a better approach to something I learned 30 years ago, I'm fully out. As imperfect as it is, I refuse to adjust something so ingrained in my muscle memory.

structured-parse release

hlfshell — Tue, 18 Nov 2025 18:15:00 GMT

Just released structured-parse, a multi-language parser for block labeled LLM output. It’s based on the parser I had built for arkaine. Here’s what I mean by “block labeleled” output: Thought: I need to search for information about robots Action: search Action Input: {"query": "robots and why they're so cool", "max_results": 5} This output is not only more human readable, but also easier for LLMs to produce. But there’s a catch - LLMs tend to still introduce nondeterministic volatility towards these outputs; humans are just good about reading through that.

Mac mini M4 Storage Upgrade: My Honest Take on the Acasis M001 and WD SN7100 NVMe

Wasi's Log — Tue, 18 Nov 2025 17:24:37 GMT

I started looking for an external NVMe setup the moment I realized how quickly my Mac mini M4’s internal storage was filling up. I use this machine every day for development and writing, and I didn’t want to babysit free space or move files around just to keep things running smoothly. Adding internal storage at […]

Every time I write about a single board computer, half the internet goes down

./techtipsy — Tue, 18 Nov 2025 16:00:00 GMT

Coincidence? Maybe.

AI adoption needs light, not hope

João Alves — Tue, 18 Nov 2025 15:33:56 GMT

As per last week’s rumors, Meta will judge employee performance based on AI skills. Nothing new. Other companies, like Zapier, have even published what they expect “AI fluency” for all new hires:

Every time a company announces “AI usage dashboards,” people get mad. My timeline on X gets full of surveillance, micromanagement, and bullshit rankings. I get the reaction. Engineers hate anything that smells like performance theater. But with something as disruptive as AI, betting on “organic adoption” is a fantasy. Habits don’t shift on their own. Teams don’t wake up one day and decide to rewrite workflows. And leaders can’t support what they can’t see.

DORA metrics at Adevinta

Back in 2021, Adevinta had a company-wide objective that counted against the variable incentive (€€€) people got. There were a lot of complaints.

You can’t measure everything through DORA (person X)

People will just fake the metrics (person Y)

And the list went on. All of this is partially true. And organizations are bound to Goodhart’s Law:

When the target becomes the goal, it ceases to be a good measure.

If we look carefully at the metrics most leaders use in big corps... You can game most of them. And yet, leaders need something they can track. If you can’t track... how do you measure progress?

So what I did back then is exactly what I’m arguing for now: make the work visible. People were frustrated with DORA because they assumed leadership only cared about the numbers. But when we treated the metrics as prompts — not goals — things started to move.

Inside the Runtime team, we started by asking simple questions: why is lead time this high? Why are deployments painful? It didn’t matter if we were an infrastructure team or a product team — the metrics pointed us to the right conversations. We weren’t comparing ourselves to anyone else. We were trying to understand our own workflow.

A small dashboard, created by Thibault, made a big difference. It showed where we were getting stuck. That led to concrete changes: smaller pull requests, thanks to stacked PRs. Easier reviews. Fewer long-running branches. And a shared awareness that code sitting in main but not in production is already drifting. Once the team saw that, they acted on it.

The metrics improved, but only because the team fixed the underlying issues. We didn’t optimize for the number. We used the number to guide our questions. That experience is why I believe dashboards matter. Not to rank people. Not to micromanage. Just to see what’s actually happening so the team can improve it.

Why dashboards work

To be clear: dashboards don’t fix your culture, and they won’t turn mediocre teams into high-performing ones. What they do is make the current reality visible. And visibility is usually the first uncomfortable but necessary step toward change.

Most companies today have a significant gap between access to AI tools and their actual use in a meaningful way. Two engineers can sit in the same team, with the same deadlines, and have radically different workflows. One gets 30 percent faster. The other barely touches the tools. Without visibility, these differences stay invisible, and nothing improves.

A good dashboard doesn’t need to be a leaderboard (although gamification also works). It can be as simple as: which teams are trying things, where they’re stuck, and where the tools actually save time. That’s enough to spark questions, conversations, and curiosity. People copy what works. They ask for help. They share tricks. That’s where culture starts shifting.

And yes, it creates pressure. The healthy kind. It puts these new skills on the same bar as other expectations. What makes people write documentation, fix tests, or share learnings? Not punishment. Clear expectations.

You don’t keep these dashboards forever. Their job is temporary. They help you move from “AI available” to “AI embedded.” Once the new habits stick and teams see the benefits, the dashboard fades into the background.

Dashboards and metrics don’t create culture. But they make the gap clear enough that teams finally close it.

— João

Early morning walks

Nicola Iarocci — Tue, 18 Nov 2025 08:50:49 GMT

An essential part of my fitness routine is my early morning walks. On weekdays, I leave my home on the outskirts of my small provincial town, walk to downtown, and then return. It’s a brisk, almost hour-long loop before I sit down at my desk. On weekends, I take walks in the woods or to the beach, or if I have the time, head out for a mountain hike.

These walks make my daily zen moment. Sometimes I come back and, if I try, I can’t remember what I was thinking about the whole time. Other times, however, and often, I mentally organize my day, or solve coding problems (or, more likely, study solutions to try later, once I’m at the keyboard). Sometimes I plan or dream about my future mountain trips, or remember past adventures, or plan motorcycle trips. Sometimes I listen to podcasts or music: there are mornings when I want to be on my own; others when listening to a well-told story is just what I need. In any case, once I get back, I feel refreshed, oxygenated, relaxed, and ready for the day’s work.

LattePanda IOTA review: how does it perform as a home server?

./techtipsy — Tue, 18 Nov 2025 06:00:00 GMT

I received a review sample of the LattePanda IOTA, here's what I did to it.

The Feedback Matrix

Home — Tue, 18 Nov 2025 02:00:00 GMT

When giving feedback on someone’s work, most feedback falls into a simple two by two matrix.

Flowbased Tutorial: CNECs and Active Constraints and how to analyse them

Blog Frank Boerman — Tue, 18 Nov 2025 02:00:00 GMT

The flowbased capacity calculation system as a whole, and the domain specifically, can be pretty daunting to people who are just learning about it. Today I wanted to give a short introduction on some key concepts. Next to that I will present some analysis methods of the active constraints. Please note that I will assume some basic linear algebra optimization knowledge throughout this post.
This post is partly based on the great work by my Hungarian collegues of MAVIR in their eCIGRE paper, reference 11358-2024. MAVIR has very knowledgeable flowbased experts and are quite well known in the small flowbased community, especially through the huge amount of work moved by Ferenc Nagy.

Toon for Oracle: A Token-Efficient Data Format for LLMs

Philipp Hartenfeller Blog RSS Feed — Tue, 18 Nov 2025 02:00:00 GMT

Toon is a data representation format that is optimized for usage for LLMs. With UC AI's PL/SQL package, you can convert any JSON data to the Toon format.

Federate Away From GitHub

Lambda Land — Tue, 18 Nov 2025 02:00:00 GMT

The past few weeks have seen major AWS, Azure, and Cloudflare outages. I predict Google Cloud will have a major outage sometime soon as well. Each time one of these massive systems goes down, it takes a sizable chunk of the internet with it. This is troubling: the internet should be more robust against partial outages.

New perspective on SLA

Padirac Innovations' blog — Mon, 17 Nov 2025 22:17:36 GMT

For many years, SOD1-related ALS was considered a special case within the disease spectrum: a subtype of ALS where the TDP-43 protein, which characterizes the pathology of most ALS cases, played a...

Nouvelle perspective sur la SLA

Padirac Innovations' blog — Mon, 17 Nov 2025 22:10:19 GMT

Pendant de nombreuses années, la SLA liée à la SOD1 a été considérée comme un cas particulier au sein du spectre de la maladie : un sous-type de SLA où la protéine TDP-43, qui caractérise...

Building a web search engine from scratch in two months with 3 billion neural embeddings

Mia Heidenstedt — Mon, 17 Nov 2025 18:39:46 GMT

Best viewed on the original page, where extended functionality like the footnote helper is available.

I stumbled upon this quite bonkers article about building a web search engine from scratch as a solo developer with relatively modest resources, i absolutely can recommend reading it:

Building a web search engine from scratch in two months with 3 billion neural embeddings

Summary (Generated):

Wilson Lin built a full web search engine from scratch in ~2 months, crawling ~280M pages and generating 3B SBERT embeddings on a GPU cluster consisting of 200 GPUs.
Lin focused on neural-embedding search, with smart HTML normalization + sentence-level chunking + contextual “statement chaining” so queries match meaning and intent, not keywords.
The infra is highly optimized + cheap: custom crawler & RocksDB-based queues/KV, sharded HNSW / CoreNN vector DB, mTLS service mesh, hundreds of GPUs on low-cost providers (Runpod, Hetzner, Oracle).
The SERP emphasizes high-quality, low-SEO-spam content, knowledge panels (Wikipedia/Wikidata), and a light AI assistant for quick answers and reranking, but still feels like a classic fast search engine.
Biggest lessons: crawling + quality filtering are the hardest part, embeddings make very specific queries vastly better, and search + LLMs will likely coexist (LLMs shouldn’t memorize everything, but retrieve via dense indices).

Experimental Environments (123)

Artificial Insights — Mon, 17 Nov 2025 15:52:09 GMT

Welcome back to Artificial Insights, your near-weekly bulletin from the near future.

Note 168

Qubyte Codes — Mon, 17 Nov 2025 11:05:31 GMT

Cold day! Fortunately, a short walk from dropping the kid off at school is Casco, one of my favourite cafes. It’s warm in here.

Androgenetic haploid selection

De Novo — Mon, 17 Nov 2025 04:41:15 GMT

How abundant eggs can increase the power of genetic selection (even if the eggs are not very good)

2025 Nov Summary

jodavaho.io — Mon, 17 Nov 2025 02:00:00 GMT

Life is really coasting along. There are always bumps, but generally great. I spend too much time at home, working and such. Of course I’m not exercising enough. But generally, being here lets me see my kiddos the maximal amount, and also to spend more time on work.

Flight Science has been a blast. We’re now fully automated!. What a journey it’s been.

My kiddos are four. I can’t really justify posting pictures of them online, but watching them swing in the backyard, fall leaves everywhere, sun setting over the water. Pure bliss. Of course one was “swinging” in the traditional sense (on a swingset), and the other was “swinging” as in trying to hit them with a stick, but they both agreed they were swinging and had a good time with the pun.

It won’t always be this good. But it is pretty good. Just need to get out and go jogging / lifting, so if anyone reads this and wants to do accountability buddies or something, you are gonna save my life!

Work/Life milestone: automated messaging

jodavaho.io — Mon, 17 Nov 2025 02:00:00 GMT

Big news! As of last week, we’re sending fully autonomous flight optimizations directly to aircraft for our partner airlines. Huge personal milestone for me, as I worked exclusively on the optimization and estimation pipelines that do this!

Why am I sending messages to cockpit screens?

Flight Science tracks flights for partner airlines, and helps them improve operations. We plug into various and sundry commercial and customer data streams; collate, estimate, and optimize things in real time; generate alerts and recommendations custom built for their objectives; and send them to the cockpit and/or dispatchers to help improve the experience, safety, and efficiency of the flight.

My background here…

I joined in 2024, and when it was just me and Andrew, we banged out the initial planning system over a couple of months. It’s iterated a dozen times at least, getting faster, more precise, and more reliable over time. I’m fond of saying that 8 my 10 favorite systems I’ve worked on were here at Flight Science.

The system has generated and sent messages for almost 1 year, but it involved me sitting at my machine and approving or denying each message. No longer! It’s stable and the recommendations are good enough that we don’t need to do that anymore.

What do we send?

Notable examples are alerts: “Turbulence ahead”, Replan: “Do this to avoid turbulence”, Efficiency: “FL320 would save xxx kg of fuel from improved following wind”, and Logistical: “Flight YYYY is due to land in 13 minutes”

How does it work?

We have precise models for key parts, optimization engines for estimating some things, and excellent heuristics for others. You can imagine we have to track the weight of all passengers, luggage, fuel, etc, the temperature of every cubic meter of air they fly through, the fractional kilogram of fuel they use for every stage of flight, airline/pilots preferred flight profile, like climb rates and speeds, and so on… And, we have to track in real time any changes to their plans - so we can look ahead for them.

Then all this information has to be piped into a real-time planner and quickly provide a batch of alternative actions, which we can score against their preferences and decide to send an alert or plan or whatever. And for each alternative we have to re-calculate projected values for all of that stuff above.

Then all this goes to the cockpit through a global satellite/vhf/hf network, and appears on one of those awesome looking little green screens, which they can ignore if they like.

Like this screen (not our message):

It’s all a suggestion for situational awareness. We do measure acceptance rate by tracking the activity of the airplane to see if they adopt the plan, it’s much higher than I expected, but more on that later.

I’m super excited. None of this would be possible if our team wasn’t already super plugged into the airline industry. We have excellent early stage partners to develop and test all this.

Amazing time.

Wien, 2025

Avy Faingezicht — Mon, 17 Nov 2025 02:00:00 GMT

Earlier this year, together with my brothers and their families, we booked a trip to Vienna and followed it up with a few days in Budapest. This was the first time we were all on a vacation together in a long time. After years of asking for it, my mom finally got her wish to do a big family trip where no one was working part time. We took a lot of photos on everyone's cell phones, but I brought my film camera and did my usual street photography thing. Results below. I also got a disposable camera for each of my nephews and nieces (yes, even the 2 year old). Those I'm keeping out of the blog but needless to say, they were a lot of fun to look through.

Learning to boot from PXE

Imran's Blog — Mon, 17 Nov 2025 02:00:00 GMT

I bought a new laptop, the GPD Pocket 4. It came with windows installed by default, and I wanted to install nix on it.

I grabbed a usb, dd'd the nixos iso image on it and tried to boot. The laptop did not recognize the drive. Turns out, the drive crapped out, no computer would boot off it.

The normal thing to do would've been to just go get a new usb and install off of and go about setting the laptop up. That meant I would either have to go outside or wait for a new usb to arrive. I don't want to outside and I don't want to wait to setup my laptop. I have free time now and I have no clue when I will have free time next.

The menu had two other boot options. Something about PXE over ipv4 or ipv6. I only knew that PXE allowed networked boot. So hey, let's use this time to learn something new.

# DHCP

As I've learned, the first half of this process is DHCP. When a device is connected to the network it sends out a "HEY GIVE ME AN IP" message (I don't actually know how it works and didn't bother to look it up). Then your DHCP service see's this message and responds back with an IP. As part of these requests the client and server can set "options" on these requests which can send additional information. I don't know what the client sets first, but I do know the server needs to set a boot file name and location of a TFTP server. TFTP sort of like FTP.

PXE reads the boot file (usually something.pxe) from the TFTP server and then executes its code. Other boot files are then retrieved as needed from the TFTP server.

While learning this, folks on the internet dont seem too fond of TFTP, saying it could be slow. There exists iPXE which is supposed to be a better PXE. PXE (like bioses), tend to be manufacturer specific and are not created equal. iPXE tries to be better and supports a bunch of other stuff like (like booting from an ISO, and talking in HTTP). So if this all goes well i get iPXE going, point it to the iso I've already downloaded and I'm off to the races!

Spoiler alert, I didn't get to the races.

To get iPXE running, the iPXE.pxe executable needs to be served by TFTP. I am running an OPNsense box for my router/firewall and it as enough disk space and ram that I should be able to do this whole process of it. Setting the DHCP stuff is easy enough via the UI. the iPXE client sets a client option on its DHCP requests, so you want to create a tag in OPNsense off it's user-class (iPXE) and respond with a DHCP boot (what the tab in the UI is called) value of the http server.

The flow should be:

PXE -> Gets TFTP Address -> Downloads and run iPXE iPXE -> Gets HTTP address -> Does iPXE stuff like run our iso

The DHCP stuff can be done through the UI so it was. The TFTP stuff was not availble the web ui so has to be done through ssh.

# TFTP

This was my first time shelling into a BSD box. After this whole process I was left feeling that (Free)BSD is oddly cozy. I can't explain how or why, but it just does. The login prompt from opnsense, the simple shell prompt (csh?), the man pages, the disk layout, the programs. Like even if I didn't have access to all the new version of tools (nvim / rg vs vim / grep) I still got what I wanted done and it just felt cute and cozy.

Anyway, OPNsense ships with dnsmasq and dnsmasq can also act as a TFTP server. I found this out when trying to search for a TFTP program to install via the UI. I don't know how to enable it, nor did I want to look it up (via the internet), so I just read the man page.

man dnsmasq

Reading the man page was a pleasant experience (or maybe it was just my first time reading something from section 8). It told me exactly what the program could do and how to configure it (just searched for tftp). The conf files were listed in at the bottom, the first being /etc/dnsmasq.conf which did not exist on my system but /usr/local/etc/dnsmasq.conf did.

The first line of that file warns you not to manually edit the file and near the bottom you see the conf-dir option set to /usr/local/etc/dnsmasq.conf.d I saw a README in that conf dir and, doing a cat resulted in this message:

cat /usr/local/etc/dnsmasq.conf.d/README
# Dnsmasq plugin directory:
# Add your *.conf files here, read in alphabetical order

Well sure why not lets do that

vim /usr/local/etc/dnsmasq.conf.d/10-tftp.conf
enable-tftp
tftp-root=/srv/tftp
:x
mkdir -p /srv/tftp
fetch -r https://boot.ipxe.org/ipxe.efi -o /srv/tftp/

I used the web ui to restart dnsmasq, but you can also use configctl to do it via shell. Now when I boot up the laptop I see it load up iPXE but then fail as the http server does not exist. That is progress though, now we just need to serve our iso over http.

One thing to note is that nearly all the instructions online focus on legacy/bios boot. All my devices boot via UEFI (which is why we downloaded the efi above instead of the .kpxe file). There are ways to setup DHCP to respond with the appropriate files for both uefi or bios boot, but I dont care enough. There are also other things that try to simplify this whole process like pixieboot and netboot.xyz but I am not interested in them.

# HTTP

OPNsense runs lighttpd for serving its web ui and I would like to piggy back off it for the iPXE stuff.

The trickest part here was finding out the web ui configuration lives at /usr/local/etc/lighttpd_webgui/ via ps. I had to disable the ssl redirect option from the web ui and instead add it myself to end of my conf file, due how the confs are loaded. I could not think of a different way of getting the 443 port redirect disabled just for the ipxe paths

cat /usr/local/etc/lighttpd_webgui/conf.d/00-ipxe.conf
# Serve /srv/tftp under http://<ip>/ipxe/
alias.url += ( "/ipxe/" => "/srv/tftp/" )
url.redirect += ( "^/ipxe$" => "/ipxe/" )

$SERVER["socket"] == "0.0.0.0:80" {
    ssl.engine = "disable"
    $HTTP["url"] !~ "^/ipxe(?:/|$)" {
        $HTTP["host"] =~ "(.*)" {
            url.redirect = ( "^/(.*)" => "https://%1/$1" )
        }
    }
}

$SERVER["socket"] == "[::]:80" {
    ssl.engine = "disable"
    $HTTP["url"] !~ "^/ipxe(?:/|$)" {
        $HTTP["host"] =~ "(.*)" {
            url.redirect = ( "^/(.*)" => "https://%1/$1" )
        }
    }
}

I started off with a basic boot.ixpe file

#!ipxe
menu Choose an ISO
item nix-minmal NixOS 25.04 Minimal
item nix-gui   NixOS 25.04 GUI
choose target && goto ${target}

:nix-minimal
sanboot http://10.0.0.1/ipxe/nixos-minimal-25.05.812242.3de8f8d73e35-x86_64-linux.iso
goto menu

:nix-gui
sanboot http://10.0.0.1/ipxe/nixos-graphical-25.05.812242.3de8f8d73e35-x86_64-linux.iso
goto menu

And here is what I spoiled eariler, it didnt work.

I would get a boot but then nixos would complain about /mnt/iso or something being missing and failing to go further.

This discussion has better information on why it doesn't work: https://github.com/ipxe/ipxe/discussions/962

# Proper netboot files

So my dreams of network booting off an iso are crushed, so where do I go from here?

Well it turns out the ISO comes with a bootloader, which contains instructions on how to boot a kernel with an initial ram disk (hint this when I learned what initrd means). So can't we do the same? The answer is yes! (or so I think). I didnt try to extract the files out the iso, but use nix's built in netboot image generator which builds the necessary files.

I only had to tweak the generated .ixpe file to include the http urls but everything worked out in the end.

cat netboot.ipxe
#!ipxe
# Use the cmdline variable to allow the user to specify custom kernel params
# when chainloading this script from other iPXE scripts like netboot.xyz
kernel http://10.0.0.1/ipxe/bzImage init=/nix/store/hrgkskx4jqdz4nl3p1f4m1dvrr9b3lij-nixos-system-nixos-kexec-25.11pre708350.gfedcba/init initrd=initrd nohibernate loglevel=4 lsm=landlock,yama,bpf ${cmdline}
initrd http://10.0.0.1/ipxe/initrd
boot

I still wonder if I can extract the files from the graphical installer and boot KDE off the network, but now that the OS is installed my interest has waned. Maybe one day I will revisit

Support For CIMD For MCP In Visual Studio Code

Den Delimarsky — Mon, 17 Nov 2025 02:00:00 GMT

A quick overview of the upcoming change to the MCP specification that introduces support for Client ID Metadata Documents (CIMD), and how it will be supported in Visual Studio Code.

Ray-Ban Meta Glasses (Gen 2)

Home — Mon, 17 Nov 2025 02:00:00 GMT

Today I met with an offshore operator in Singapore. They charter boats, move crews, move cargo, keep offshore platforms running. Someone in the meeting said something simple and true: no matter how much technology you give people, people remain a major factor in the equation.

Towards interplanetary QUIC traffic

Consulting on Adolfo Ochagavía — Mon, 17 Nov 2025 02:00:00 GMT

Have you ever asked yourself which protocols get used when downloading pictures from the Perseverance Mars rover to Earth? I hadn’t thought about that either, until I came across an intriguing message on the internet, back in April 2024: I’m looking for someone knowledgeable of quic/quinn to help us out for our deep space IP project. Would be of part-time consulting. Please dm me if interested. The message itself is quite short and somewhat jargon-y, so it took me a few readings to fully realize what the project was about:

Photos from November 17th, 2025

cjlm.ca — Mon, 17 Nov 2025 02:00:00 GMT

Quoting Stewart Lee

cjlm.ca — Mon, 17 Nov 2025 02:00:00 GMT

On fact-checking

[David Davis] said, our new establishment, academics, quango-crats and the BBC, are obsessed with misinformation and disinformation. They believe that you are too stupid to distinguish between the true and the false. And they think it’s the government’s job, or perhaps theirs, to do it for you instead.

Well, it is someone’s job, unfortunately, because we’re now in an immersive hellscape.

On information

If you Google me, where am I playing? You come to all these … pages where you have to sign up for alerts, and they pay to be put higher up the search engine than my actual [site]. And you have to get through all those, and I don’t want them to be there. There’s no need for them.

But there’s all these barriers created to information where the process is monetized by things that are sort of not quite true.

— Stewart Lee , Strong Message Here

Writing every week

Something About Cats — Sun, 16 Nov 2025 23:44:46 GMT

Or: putting my money where my keyboard is

Notification Contexts Matter

LornaJane — Sun, 16 Nov 2025 23:13:26 GMT

Like many of you, my days are dominated by notifications. Emails from project management systems, source control systems, calendar invitations, ticket updates, and message about messages on other platforms. I’ve noticed that some people use notifications as a power tool, … Continue reading →

Interessant3 #167 | 🇫🇮The Resilience of Sisu,💧Desalination Economics, 🧬Genetics & Meritocracy

Interessant3 — Sun, 16 Nov 2025 21:37:36 GMT

Three Interesting Things for W/C 2025-11-16

Empirical vs Generative Data

🦉 olshansky 🦁 — Sun, 16 Nov 2025 17:55:41 GMT

The last decade was about evaluating empirical data.

The next decade is about evaluating generative data.

Synthetic data itself isn’t the goal, understating it is.

Bio links, Fall 2025

De Novo — Sun, 16 Nov 2025 04:28:21 GMT

Some interesting stuff I've read recently

The Far Side of the Moon

🦉 olshansky 🦁 — Sun, 16 Nov 2025 04:04:40 GMT

Review of Ex Machina's Production presented on the Canadian Stage

The Secret History by Donna Tartt

Apurva Shukla's RSS Feed — Sun, 16 Nov 2025 03:52:53 GMT

⭐ ⭐ ⭐ I was recommended this book by a friend, and told to read it during winter. I brought it with me on my travels, and read it through…

The Stranger by Albert Camus

Apurva Shukla's RSS Feed — Sun, 16 Nov 2025 03:49:41 GMT

⭐ ⭐ ⭐ ⭐ The Stranger by Albert Camus was a provoking read, of a man who seemingly has lost the depth of emotion. I wonder if his stoicism…

The Women I Think About At Night by Mia Kankimäki

Apurva Shukla's RSS Feed — Sun, 16 Nov 2025 03:38:34 GMT

⭐ ⭐ ⭐ There was a point I thought I had lost this book while camping in Victoria Falls in Zimbabwe, and I frantically tried searching for it…

Terminal Boredom by Izumi Suzuki

Apurva Shukla's RSS Feed — Sun, 16 Nov 2025 03:33:55 GMT

⭐ ⭐ ⭐ I picked up this book in a bookshop I returned to twice in Rio de Janeiro. It struck out to me with it’s yellow cover and interesting…

The Art of Travel by Alain De Botton

Apurva Shukla's RSS Feed — Sun, 16 Nov 2025 03:33:55 GMT

⭐ ⭐ ⭐ ⭐ ⭐ I read the Art of Travel with rapidity to prepare me for a three month expedition I was about to embark on. I hoped to glean…

Outline by Rachel Cusk

Apurva Shukla's RSS Feed — Sun, 16 Nov 2025 03:13:06 GMT

⭐ ⭐ ⭐ ⭐ ⭐ Outline by Rachel Cusk was experimental. It followed the author herself through a series of vignettes with friends and strangers…

The Plague by Albert Camus

Apurva Shukla's RSS Feed — Sun, 16 Nov 2025 03:13:06 GMT

⭐ ⭐ ⭐ ⭐ I picked up this book in 2025, a couple years after COVID-19 ravaged across the world, grounding airplanes, locking borders…

The Courage to be Disliked by Ichiro Kishimi & Fumitake Koga

Apurva Shukla's RSS Feed — Sun, 16 Nov 2025 02:50:02 GMT

⭐ ⭐ ⭐ ⭐ I listened to The Courage to Be Disliked as I ran earlier this year, and it was a curious experience. I think listening to it was…

How FOSS Won and Why It Matters

Musings about software — Sun, 16 Nov 2025 02:00:00 GMT

I regularly comment on the Internet on my views on most schemes proposed to fix FOSS problems. They are mostly negative. I think that most of these schemes cannot achieve any meaningful impact. It seems that most of these disagreements come from the fact that I seem to work on different models of how FOSS work. Over the years, I have tried to share parts of my model. This is part of this endeavor.

Ad-Hoc Emacs Packages with Nix

Fernando Borretti — Sun, 16 Nov 2025 02:00:00 GMT

Creating ad-hoc Emacs packages in a few lines of code.

Your Data Model is Your Destiny

Dan Stroot — Sun, 16 Nov 2025 02:00:00 GMT

The importance of a differentiated data model is rising dramatically. AI is commoditizing code. Technical execution is table stakes rather than a competitive advantage. Your product's core data abstractions determine whether new features compound into a moat or just add to a feature list. Here's how to get it right.

This post Your Data Model is Your Destiny first appeared on Dan Stroot's Blog

Drowning in AI Research Papers? Meet Muves: Your AI-Powered Research Assistant

Stories by Dmitry Kan on Medium — Sat, 15 Nov 2025 23:13:26 GMT

Just recently Hugging Face announced their collaboration with Meta to build the successor to Papers With Code (PWC), which has been sunset:

BREAKING: | Julien Chaumond | 126 comments

If you’ve ever tried to keep up with the latest artificial intelligence research, you know the struggle. Every day brings a flood of new papers, breakthrough discoveries, and technical innovations. What was once a manageable stream of publications has become a raging river of information that even seasoned researchers find difficult to navigate.

Meet Papers, an AI-powered workspace that’s changing how we collect, organize, and understand AI research. Think of it as your personal research assistant that never sleeps, never gets overwhelmed, and always remembers where you left that important paper about transformer architectures.

The AI Research Avalanche

At the time of this writing, arXiv sees 24,000 publications uploaded monthly.

Monthly submissions to arXiv exceed 24000 papers: https://arxiv.org/stats/monthly_submissions

The numbers are staggering. While not all papers are on AI topic, Computer Science on arXiv has been dominating in volume compared to math, physics, quantitive biology and finance etc in the past 5 years.

Submissions to arXiv by category, last 5 years: https://info.arxiv.org/about/reports/submission_category_by_year.html

With the volume of AI research growing almost exponentially, staying current with meaningful developments is a constant challenge — even for experts. We’re living through what many consider the golden age of AI research, with breakthroughs happening at breakneck speed across machine learning, natural language processing, computer vision, automatic speech recognition and beyond.

But here’s the paradox: the very field that’s supposed to make information processing easier has created an information overload problem for its own practitioners.

PhD students spend hours sifting through ArXiv. Industry researchers struggle to identify which papers are worth their time. Even AI pioneers find themselves drowning in the sea of publications they helped create.

What Makes Muves Papers Different

Papers isn’t just another paper repository or bookmark manager. It’s a comprehensive research platform designed specifically for the modern AI researcher’s workflow.

Intelligent Discovery

Instead of manually hunting through endless paper lists, Papers actively helps you discover trending research and key developments. The platform cuts through the noise to surface papers that matter, using AI to identify genuine breakthroughs from incremental work.

Project-Centered Organization

One of Papers’ most powerful features is its project-based organization system. Whether you’re working on computer vision for autonomous vehicles, exploring large language models, or diving into reinforcement learning, you can create dedicated project spaces that keep related research organized and accessible. What is also handy, is that you can upload and analyze a paper of your own, if you wrote one or found one online or on an old USB flash drive.

Workspace: a collection of projects, with each project holding papers. This helps you organize your research process, generate literature review and chat to papers in the given project

Helping you conduct science

If you are a research scientist, MSc / PhD student, your research often times starts with doing a literature review. In other words, you’d like to know what has been done so far on the topic of your choice. Doing so is important, but can also take a long amount of time. This is where Papers offers an automated Literature Review. To access it, create a project, add relevant papers and hit the button “Generate Literature Review”.

Literature review, generated in the project “Reasoning LLMs”

If you need to, you can make edits to the text, or just download the PDF version to accompany your seminar presentation or a chat with your supervisor(s).

AI-Assisted Understanding

Perhaps most importantly, Muves doesn’t just store papers — it helps you understand them. The platform’s AI capabilities break down complex research into clear summaries, making it easier to grasp key concepts without getting lost in technical jargon.

Picking on the paper from the previous screenshot, I have clicked on the “View analysis” blue button and got this output:

Example of a paper analysis

Related papers

When viewing a detailed paper page, in addition to the paper’s abstract and analysis (like you saw in the previous section), Papers will present the list of papers, related to the given paper’s topics.

For example, for the paper “ReasonRank: Empowering Passage Ranking with Strong Reasoning Ability” I currently see the following papers as related:

Upload a paper (or any PDF)

To make sure you can conduct your research not only based on the available sources, like arXiv, we added a feature for uploading any PDF file. For example, I’ve uploaded an entire book called “Principles of Building AI Agents”, and Papers managed to correctly parse the book’s author (Sam Bhagwat), publication year (2025), and even the page with the author’s photo and recommendations of readers.

Detailed page of the “Principles of Building AI Agents” book

Now imagine you can upload any document at all to study it more precisely. Everything you upload will be visible only to you, to preserve your data privacy.

Muves Research Assistant

What sets Papers apart is its conversational Research Assistant we called Muves. Imagine being able to chat with your entire research collection, asking questions like:

“What are the latest trends in transformer architectures?”
“How do these three papers on few-shot learning relate to each other?”
“Can you generate a literature review for my project on multimodal AI?”

Chat to paper(s) feature: relation between papers

Chat to paper(s) feature: asking a general question about trends in transformer architectures

This isn’t science fiction — it’s the reality of modern research tools. The Muves Research Assistant can generate literature reviews, help you spot connections between papers, and even assist with citation management.

Beyond Individual Productivity

While Papers aims to solve individual productivity challenges, its potential impact extends beyond personal research management. By making AI research more accessible and digestible, tools like Papers are democratizing access to cutting-edge knowledge.

Graduate students who might otherwise struggle with the overwhelming literature can now engage more effectively with research. Industry practitioners can stay current with academic developments without dedicating their entire day to paper reading. Even seasoned researchers can explore adjacent fields more efficiently.

The Future of Research Management

Papers represents a broader trend in academic tooling — the application of AI to solve problems created by AI’s own success. As research velocity continues to accelerate, we need increasingly sophisticated tools to help us navigate the knowledge landscape.

The platform’s approach suggests a future where research tools are not just repositories but active participants in the research process. Instead of passive databases, we’re moving toward intelligent research partners that can synthesize information, identify patterns, and generate insights.

Getting Started

For researchers tired of drowning in papers, Papers offers a lifeline. The platform’s AI-powered workspace provides the structure and intelligence needed to transform overwhelming research chaos into organized, actionable knowledge.

Whether you’re a PhD student beginning your research journey, an industry professional trying to stay current, or a seasoned researcher looking to streamline your workflow, Papers offers a new way to engage with AI research — one that emphasizes understanding over accumulation, insight over information.

In a world where staying current with AI research feels like an impossible task, Papers proves that the solution might just be more AI. Sometimes the best way to solve a problem created by technology is with better technology.

Philipp was annoyed

Annoying Technology — Sat, 15 Nov 2025 20:33:38 GMT

If only there was a way for a cloud service to do background tasks without relying on the user’s browser to stay open.

A wild rolisz reappears

rolisz's blog — Sat, 15 Nov 2025 09:04:17 GMT

I haven't written a blog post in a long time. It's been a tough year. Mostly from a health perspective. One of the highlights was when I cracked four ribs from coughing (yes, the doctors were just as shocked as you are). Before that, I used

Birds • Art

Muffin Man — Sat, 15 Nov 2025 02:00:00 GMT

I love everything about these. The process was so much fun and I'm super happy how the plots turned out.

I got the idea while playing with vector fields and noticed that some shapes resembled a bird. I started tweaking the algorithm and after a lot of experimentation, made a tool that procedurally generates birds.

The first drawing is 22x22cm, and others are around 15x15cm.

As usual, these are hard to photograph (which is why it took me ages to post them here), so thanks to my friend David for letting me use his studio lighting to take proper photos.

Created:	November 2025
Size:	Various sizes
Paper:	Fabriano Black Black 300gsm
Pens:	Molotow Liquid Chrome, UniBall Signo and Sakura Jelly Rolls

Life Goes On

ho.dges.online — Sat, 15 Nov 2025 02:00:00 GMT

Oh yeah, life goes on
Long after the thrill of living is gone…

John ‘Cougar’ Mellencamp, ‘Jack & Diane’

Linux on the Fujitsu Lifebook U729

Fernando Borretti — Sat, 15 Nov 2025 02:00:00 GMT

A short review and troubleshooting guide.

Automating rootless Docker host updates with Ansible

du.nkel.dev — Sat, 15 Nov 2025 02:00:00 GMT

Running apt upgrade on hosts with rootless Docker services can break them. A version mismatch occurs between the running user daemon and the newly upgraded system binaries, causing containers to fail on restart. This post provides an ansible playbook that detects critical package changes and automatically restarts only the necessary rootless user daemons, preventing downtime and manual intervention.

Sick of cables? Switch to 5G Home Internet!

Jason Eckert's Website and Blog — Sat, 15 Nov 2025 02:00:00 GMT

I’ve been using 5G Home Internet for well over a year now, and honestly, I love it. For my lifestyle and day-to-day Internet habits, it has hit the sweet spot between performance, convenience, and simplicity. If you’ve ever wondered whether 5G Internet is a realistic alternative to cable or fibre for your home, I’m going to share the details and my experience in this blog post.

Walmart CEO Doug McMillon To Retire

The Techee — Sat, 15 Nov 2025 00:22:55 GMT

Doug McMillon, the chief executive officer (CEO) of retail giant Walmart (NYSE: WMT), has announced his imminent retirement. He’ll step down on January 31, 2026, and be replaced by John Furner, current CEO of Walmart’s U.S. division. McMillon has been Walmart’s chief executive since February 2014. He has worked at the Arkansas-based retail giant since […]

The post Walmart CEO Doug McMillon To Retire appeared first on The Techee.

Listening on an ephemeral TCP port

Blog on blog.gnoack.org — Fri, 14 Nov 2025 21:26:44 GMT

The classic TCP client/server interaction

When a TCP client calls connect(2), it usually gets assigned a port number from the ephemeral port range which is not used yet.

The server, on the other hand, usually calls bind(2) to set the port that it will listen on.

Some less known fun facts

Servers that listen on random ports

While a server will usually bind(2) itself to a fixed port number, it can absolutely omit that, and then, when it calls listen(2), the server will get an ephemeral port assigned by the kernel which it will then listen on. (This is similar to setting the bound port number to 0.)

Clients that use a specific port number

If a client socket uses bind(2) before connect(2), the client can enforce using a specific port number for its own side.

Reference

The best description I found of this is in ip(7):

An ephemeral port is allocated to a socket in the following circumstances:

the port number in a socket address is specified as 0 when calling bind(2);

listen(2) is called on a stream socket that was not previously bound;

connect(2) was called on a socket that was not previously bound;

sendto(2) is called on a datagram socket that was not previously bound.

So the behaviour of bind(2) actually works the same on both client and server sockets. It’s just in daily use where it only gets used for server sockets.

Previous discussion on the kernel mailing lists

Almond by Sohn Won-Pyung

Apurva Shukla's RSS Feed — Fri, 14 Nov 2025 15:41:06 GMT

⭐ I tried to like Almond, but I didn’t at all. I think it’s perhaps because it was hard to empathise with a character who has no feelings…

Winter’s warmth

Notes from the Burrow — Fri, 14 Nov 2025 09:12:33 GMT

There’s this dampness that sets upon my mental state as the winter comes around. At first, it wraps my routines where working out becomes harder, waking up early enough for...

Obsidian Bases: Formula for star ratings with half stars

Nithin Bekal — Fri, 14 Nov 2025 02:00:00 GMT

I recently started using Obsidian and have been enjoying the Bases feature, which lets you create database-like views using structured notes.

Agda on NixOS

Fernando Borretti — Fri, 14 Nov 2025 02:00:00 GMT

Troubleshooting notes.

The Physics of Software Development

Domenico Luciani — Fri, 14 Nov 2025 01:00:00 GMT

As a software engineer let's use a tool to discuss with business and get out from there like a boss would do.

Une critique d'un article sur la stimulation spinale par courant continu dans la SLA

Padirac Innovations' blog — Thu, 13 Nov 2025 22:22:49 GMT

Une étude récente affirme qu’une forme de stimulation électrique spinale améliore considérablement la survie et la fonction motrice chez la souris SOD1-G93A, un modèle de SLA. Mais un examen...

Dell XPS 13, solid as a rock

Bajkowski.com — Thu, 13 Nov 2025 06:12:48 GMT

Ownership experience of using the Dell XPS 13 laptop over the last ten years

Photos from November 13th, 2025

cjlm.ca — Thu, 13 Nov 2025 02:00:00 GMT

x86 Addressing Modes, Part 1 — Immediate and Direct Access

Confessions of a Code Addict — Wed, 12 Nov 2025 18:15:23 GMT

The foundations of memory access: static allocation, addressing modes, and the first steps toward low-level thinking.

docker-harness got a mini-makeover

hlfshell — Wed, 12 Nov 2025 18:15:00 GMT

Just pushed a pretty significant update to docker-harness. It was a tool I created originally to power some of my Docker containerized database tests. I pulled out the dependencies for each database to modularize it a bit. Each database module (MySQL, PostgreSQL, Redis, Memcached) now has its own go.mod and go.sum, which means you only pull in the dependencies for the databases you actually need. Also added some dependency updates, taking out old dependencies that weren’t needed anymore, while also ensuring that anything that has been deprecated or abandoned wasn’t being used.

What AI I Use How and When (November 2025 Update)

Eleanor on Everything — Wed, 12 Nov 2025 15:01:02 GMT

This is a follow-up to my March 2025 report on the AI tools I use.

What It Really Means To Be Calm

Ashley Janssen Consulting — Wed, 12 Nov 2025 13:00:30 GMT

There is a difference between calming things down, achieving a state of calm, and a chaos-free life. Learn why it matters and how to be intentional about cultivating a calmer life.

The Two Jobs of a CPO

Stay SaaSy — Wed, 12 Nov 2025 08:59:22 GMT

One of the hardest things I've found about being a Head of Product / Chief Product Officer is that you really have two jobs: Setting product culture, and setting product strategy.

Creating recurring tasks in Todoist with cron

David Schlachter — Wed, 12 Nov 2025 04:45:00 GMT

My approach to managing and creating repeating tasks using a cron scheduler in Todoist.

Want a WhatsApp Emacs client? Will you fund it?

xenodium.com @alvaro — Wed, 12 Nov 2025 02:00:00 GMT

Like it or not, WhatsApp is a necessity for some of us. I wish it weren't the case, but here we are.

Given the circumstances, I wish I could use WhatsApp a little more on my terms. And by that, I mean from an Emacs client, of course. Surely I'm not the only one who feels this way, right? Right?! Fortunately, I'm not alone.

With that in mind, I've been hard at work prototyping, exploring what's feasible. Spoiler alert: it's totally possible, though will require a fair bit of work.

Thankfully, two wonderful projects offer a huge leg up: wuzapi and whatsmeow.

wuzapi offers a REST API on top of whatsmeow, a Go library leveraging WhatsApp's multi-device web API.

Last week, I prototyped sending a WhatsApp message using wuzapi's REST API.

I got there fairly quickly by onboarding myself on to wuzapi using its web interface and wiring shell-maker to send an HTTP message request via curl. While these two were enough for a quick demo, they won't cut it for a polished Emacs experience.

While I can make REST work, I would like a simpler integration under the hood. REST is fine for outgoing messages, but then I need to integrate webhooks for incoming events. No biggie, can be done, but now I have to deal with two local services opening a couple of ports. Can we simplify a little? Yes we can.

You may have seen me talk about agent-shell, my Emacs package implementing Agent Client Protocol (ACP)… Why is this relevant, you may ask? Well, after building a native Emacs ACP implementation, I learned a bit about json-rpc over standard I/O. The simplicity here is that we can bring bidirectional communication to an Emacs-owned process. No need for multiple channels handling incoming vs outgoing messages.

So where's this all going?

I've been prototyping some patches on top of wuzapi to expose json-rpc over standard I/O (as an alternative to REST). This prototype goes far beyond my initial experiment with sending messages, and yet the Emacs integration is considerably simpler, not to mention looking very promising. Here's a demo showing incoming WhatsApp messages, received via json-rpc, all through a single Emacs-owned process. Look ma, no ports!

It's feasible (but still lots to do)

These early prototypes are encouraging, but we've only scratched the surface. Before you can send and receive messages, you need to onboard users to the WhatsApp Emacs client. That is, you need to create a wuzapi user, manage/connect to a session, authorize via a QR code, and more. You'll want this flow to be realiable and that's just onboarding.

From there, you'll need to manage contacts, chats, multiple message types, incoming notifications… the list goes on. That's just the Emacs side. As mentioned, I've also been patching wuzapi. My plan is to upstream these changes, rather than maintaining a fork.

Will you fund the work?

I've prototyped quite a few things now, including the onboarding experience with QR code scanning. At this point, I feel fairly optimistic about feasibility, which is all pretty exciting! But there's a bunch of work needed. Since going full-time indie dev, I have the time available (for now), but it's hard to justify this effort without aiming for some level of sustainability.

If you're interested in making this a reality, please consider sponsoring the effort, and please reach out to voice your interest (Mastodon / Twitter / Reddit / Bluesky).

Reckon a WhatsApp Emacs client would help you stay focused at work (less time on your phone)? Ask your employer to sponsor it too ;-)

The new maxleiter.com

Max Leiter — Wed, 12 Nov 2025 02:00:00 GMT

I redesigned maxleiter.com this week. I've wanted to make it more personal and opinionated for a long time,
but felt I lacked the expertise to do it justice.
With v0 and Claude Code (and some manual cleanup) it only took a few hours.

If you haven't played with the homepage yet, some of the features are:

Draggable and resizable windows, including the blog posts
A web-friendly version of KnightOS in the Calculator app
A terminal app with some fun easter eggs
You can full-screen the windows, and some redirect to real pages (like the blog posts)

Going into this I had some constraints:

Remains snappy and is SSR'd at build-time
Must work without JavaScript enabled
Uses new web platform features

Preloading iframes

If you open a blog post, it opens in a windowed app. I originally rendered the SSR'd MDX, and that worked,
but it involved either:

Sending every post in the initial payload (not great for performance)
Fetching the post content on demand (not great for UX)

Instead, I render a frame that points to the actual blog post page. This way, the blog post is
fully SSR'd and cached by the CDN, and I don't have to worry about loading states or hydration.

My naive approach was just to iframe each post when the window opened. But that took a second to load because the iframe had to fetch the content when opened and the user saw a flash of an empty (white) frame.
I thought about preloading with the <link rel="preload"> tag, but support for that is lacking across browsers.

So instead, I used a trick that looks like this:

export function BlogPostIframePreloader() {
  const [preloadedPost, setPreloadedPost] = useState<string | null>(null)
  const onMouseEnter = (postSlug: string) => setPreloadedPost(postSlug)
  const onMouseLeave = () => setPreloadedPost(null)

  return (
    <>
      <ul>
        <li
          onMouseEnter={() => onMouseEnter('the-new-maxleiter-com')}
          onMouseLeave={onMouseLeave}
          onTouchStart={() => onMouseEnter('the-new-maxleiter-com')}
          onTouchEnd={onMouseLeave}
        >
          The New maxleiter.com
        </li>
      </ul>

      {preloadedPost && (
        <iframe
          src={`/blog/${preloadedPost}?embed=true`}
          className="hidden"
          aria-hidden="true"
        />
      )}
    </>
  )
}

When the user hovers over (or touches) a blog post link, I render a hidden iframe that preloads the content.
Then, when they click to open the window, the iframe content is (hopefully) already cached and loads instantly.

View Transitions

View Transitions are pretty cool. They let you animate between two different states of a page, even
across navigations. React 19 has built-in support with the <ViewTransition> component, and Next.js 16 supports them with the experimental.viewTransition flag.

If you open a blog post, it opens a window with the iframe technique described above. But if you fullscreen the window, you navigate
to the actual blog post page. In supported browsers, this transition is animated:

I use Firefox, so I can't see this in action. But it works great in Chromium-based browsers.

Progressive Enhancement

If JavaScript is disabled or slow to load, the site still works. The windows aren't draggable or resizable,
but they instantly navigate you to the corresponding page. Here's how links work instantly, even before the client code loads:

This is accomplished by wrapping the apps in Next.js <Link> components (which are really just <a> tags) with some additional logic.
When JavaScript loads, I prevent the default navigation and open the windowed app instead:

<Link
  href={app.href}
  onClick={(e) => {
    e.preventDefault()
    openApp(app.id)
  }}
>
  {app.name}
</Link>

The Time Doesn't Flash

Once I published the redesign, I noticed the clock in the top-right corner was showing 6am for a split second before updating to the correct time. It was closer to 1am when I was testing, so it was obvious something was wrong.
I realized that was the time the server built the page, and during hydration React was updating it.
To solve this, I used a trick my very talented coworker Ethan wrote about in A Clock That Doesn't Snap.
The trick is injecting a small script that injects the current time into the window object before React hydrates:

<script
  dangerouslySetInnerHTML={{
    __html: `(${(() => {
      const clock = document.getElementById('menubar-clock')
      if (!clock) {
        return
      }

      const time = new Date().toLocaleTimeString([], {
        hour: '2-digit',
        minute: '2-digit',
      })

      window.__INITIAL_TIME__ = time

      clock.textContent = time
    }).toString()})()`,
  }}
/>

If you want to know why I set the clock's `textContent` and `window.__INITIAL_TIME__`, you'll need to read Ethan's post.

Conclusion

This was fun. Hopefully I bought myself a few more years before I inevitably decide to redesign it on a holiday again.
And maybe the LLMs (and you) will learn a few tricks from this post.

Photos from November 12th, 2025

cjlm.ca — Wed, 12 Nov 2025 02:00:00 GMT

A Coalition For The Future

Second Thoughts — Wed, 12 Nov 2025 00:01:28 GMT

If we can keep it

Where Veterans Can Get Free Meals on Veterans Day 2025

Light of Reason — Tue, 11 Nov 2025 20:01:32 GMT

Veterans Day is observed every year on November 11. The date never changes. What day...

Musselburgh Links

Wigs on the Green — Tue, 11 Nov 2025 18:03:07 GMT

History, Hickory, Fun

Yes, OpenAI Scrapes Google Search

Quantable Analytics — Tue, 11 Nov 2025 17:24:33 GMT

My last story about ChatGPT scraping Google and leaking prompts received a lot of attention, and I was especially pleased to see that OpenAI said that they’ve fixed the issue. So what was “the issue”, and what did they fix? My research with Slobodan Manić on the topic showed two things: Some raw ChatGPT prompts […]

The post Yes, OpenAI Scrapes Google Search appeared first on Quantable Analytics.

Raspberry Pi SSD Optimization

Bhupal's Web Page — Tue, 11 Nov 2025 09:37:28 GMT

Optimize Your Raspberry Pi to Run Fully from an SSD Cloning your Raspberry Pi OS from an SD card to an SSD can dramatically improve speed, reliability, and disk longevity. In this guide, we’ll walk you through a complete setup, from cloning to SSD optimizations. Step 1: Boot from the SSD After cloning your SD […]

I converted a rotary phone into a meeting handset

Stavros' Stuff — Tue, 11 Nov 2025 03:48:23 GMT

The meeting stakes are high when you can get hung up on

As you may remember, or completely not know, I have a bit of a fascination with old rotary phones. Occasionally, when people learn about this fascination, they donate their old rotary phones to me, so I have ended up with a small collection.

The other thing I have a fascination with is meetings. Well, I say “fascination”, but it’s more of a burning hatred, really. One day, a few months ago, I was in one such meeting, as I have been every day since, and I jokingly pretended to get irate about something.

One of my coworkers laughed and said “I bet if this were a phone call, you’d slam the phone down right now”, and a dread spread over me. Why didn’t I have a phone handset I could slam down? Had I really become a corporate husk of my former, carefree self, puppeteered by

How I’m Cutting Body Fat Without Losing Muscle

RobKohr's Blog — Tue, 11 Nov 2025 02:00:00 GMT

How I’m Cutting Body Fat Without Losing Muscle

A squeaky nail, or the wheel that sticks out

Prashanth Sadasivan — Tue, 11 Nov 2025 02:00:00 GMT

There are two proverbs which describe a similar behavior but result in polar opposite consequences and ultimately have very different morals:

OWASP Top 10 for 2025

Security Wale — Mon, 10 Nov 2025 19:19:50 GMT

The new list of top 10 security risks from OWASP for web applications

The Loyalty Investigation

Into the Details — Mon, 10 Nov 2025 16:30:42 GMT

In this post, I share the fascinating story of my grandfather who escaped Nazi Austria and stood up to McCarthyism in the U.S.; and about his father who was a Zionist and murdered in 1938 Nazi Austria

Simple Webhook-Tester in OpenShift

zufallsheld — Mon, 10 Nov 2025 16:00:00 GMT

I needed to check the payload my alertmanager in OpenShift was sending out to the target-system (which was not under my control and I couldn’t check what was received).

There is some documentation online. However at the time of writing, the example in the documentation was not usable out-of-the-box …

I found the best use case for AI

./techtipsy — Mon, 10 Nov 2025 06:00:00 GMT

I've been pushing the limits of LLM-based tooling at work, with amusing results.

New scripts: vstat.sql & dstat.sql for showing Oracle Sysmetric history with 1-minute granularity

Tanel Poder Blog — Mon, 10 Nov 2025 04:53:07 GMT

Here are two scripts for showing GV$SYSMETRIC_HISTORY contents in a simple tabular way:

vstat.sql - show up to one hour of current history at 1-minute granularity from memory
awr/dstat.sql - show 1-minute granularity sysmetric history across your entire AWR history

The database metrics infrastructure was introduced back in Oracle 10g, so you (and built-in tuning advisors) could use typically needed metrics in a standardized precomputed manner, without having to do various V$ snapshots and performance counter math yourself.

Moving form Logseq to Obsidian

Nithin Bekal — Mon, 10 Nov 2025 02:00:00 GMT

I switched to Obsidian for note taking this week, after over 3 years of using Logseq. Despite loving Logseq’s outliner format, I’ve found the app, especially the mobile app, to be slow and frustrating to use. If you’re looking to choose between the two, I hope the notes below help you see some of the tradeoffs.

Photos from November 10th, 2025

cjlm.ca — Mon, 10 Nov 2025 02:00:00 GMT

Remembering, A Trip to Seaford

Murphy's Lab Notes on Murphy's Lab — Mon, 10 Nov 2025 02:00:00 GMT

Dear Seaford: I hope that on Remembrance Sunday that you took the time to remember those who gave their time, their health, both physical and mental, their family’s wellbeing, their potential descendants, and even their lives to preserving your freedom. If not, perhaps you will pause for two minutes on the eleventh. Since I’m in Canada, I will be participating in remembering when I wake up on Remembrance Day. I had hoped to do part of that remembering earlier this year, on March 18th, in Seaford, if the opportunity hadn’t been denied.

PETaflop cluster

Justin Garrison's Homepage — Mon, 10 Nov 2025 02:00:00 GMT

AI is a pain in the back.

Fetch The Flag 2023 Bedsheets Writeup

Justus Perlwitz — Mon, 10 Nov 2025 02:00:00 GMT

This is a writeup for the Fetch The Flag 2023 Bedsheets challenge.

PyTorch Fundamentals - Week 1, 2, & 3

Playground — Mon, 10 Nov 2025 02:00:00 GMT

Brushing up on my PyTorch skills every week. Starting from scratch. Not in a hurry. The goal is to follow along TorchLeet and go up to karpathy/nanoGPT or karpathy/nanochat. Summary of the 1st three weeks.

Interessant3 #166 | 📰Media Bias, 🌳Brazilian Forests, ☀️Solarpunk in Africa

Interessant3 — Mon, 10 Nov 2025 00:17:08 GMT

Three Interesting Things for W/C 2025-11-09

The Key Lesson I Learned After Nearly a Decade in Crypto

🦉 olshansky 🦁 — Sun, 09 Nov 2025 19:10:24 GMT

Why Pragmatism Beats Idealism in the Crypto Industry

AI and the Sense of Self

Zappable — Sun, 09 Nov 2025 18:27:56 GMT

How AI will cause us to question what it means to be human

Vers un ralentissement de la maladie d'Alzheimer?

Padirac Innovations' blog — Sat, 08 Nov 2025 12:32:45 GMT

[Lata Chaunsali et ses collègues de Virginia School of Medicine ont utilisé le modèle murin 5XFAD de la maladie d'Alzheimer pour étudier le rôle des réseaux périneuronaux][2] autour des...

How to Prompt ChatGPT for Visually Appealing Web Pages

Bhupal's Web Page — Sat, 08 Nov 2025 11:12:07 GMT

Practical tips for developers and designers who want to create aesthetically pleasing, professional, and modern visually appealing web layouts using AI assistance. 🎯 1. Start with Intent, Not Code Begin your prompt by explaining why the section exists. This helps set the design context before jumping into code. Example: “I want a footer that feels […]

Pádraig Ó Tuama on prayer

Jason O'Neil — Sat, 08 Nov 2025 08:56:28 GMT

I love these reflections on prayer from Pádraig Ó Tuama in his Poetry Unbound episode “Ernesto Cardenal – Give Ear To My Words”. I’ve enjoyed his podcast for some time now, and I don’t think I realised how much of a theologian he is – I have a lot of respect for the way he […]

AI Market Makers

Ben Bolte — Sat, 08 Nov 2025 02:00:00 GMT

Framework for thinking about a type of startup that might succeed.

AI Minus Vagina

taylor.town — Sat, 08 Nov 2025 02:00:00 GMT

Did R2-D2's dong bring balance to the force?

Bridging Python and C++ in LED Matrices

ty-porter — Sat, 08 Nov 2025 02:00:00 GMT

When it comes to LED matrices, I’m sort of famous for not actually having a lab setup (see: posts tagged with RGBMatrixEmulator and RGBMatrixEmulator itself) and prefer to emulate in software. However, this week, I got to play with a real Raspberry Pi again, and it wasn’t just the usual “flash an SD card, download some software, push some pixels”. I got to dig into the guts of Python, Cython, and how the two are connected after Pillow (the popular Python imaging library) removed low-level access to its image array. I found it interesting, so let’s dive in!

The Scenario

Earlier this year, the MLB LED Scoreboard team was tracking an upcoming deprecation regarding unsafe access to the image array backing PIL.Image instances which would be removed in version 12.0.0. We traced it to the rpi-rgb-led-matrix SetImage() call that the scoreboard uses in limited fashion. As a reminder, rpi-rgb-led-matrix is the software driver that interfaces between Raspberry Pi and HUB75 LED matrices. SetImage() takes a Pillow Image object and draws all pixels in that image to the matrix. For our project, it is only used to temporarily display the MLB logo on script boot while data is fetched from MLB’s APIs. Losing this wasn’t a huge issue, as we can just blank the matrix during this time instead. Regardless, we opened an issue to track it upstream.

Fast forward to a couple weeks ago, and Pillow 12.0.0 is imminent, so I decided to take a closer look as the issue wasn’t fixed yet.

For all the code snippets below, we’ll be looking at rpi-rgb-led-matrix bindings/python/rgbmatrix/core.pyx on commit a18883, prior to fixing the issue.

Here’s the original code from SetImage():

    def SetImage(self, image, int offset_x = 0, int offset_y = 0, unsafe=True):
        if (image.mode != "RGB"):
            raise Exception("Currently, only RGB mode is supported for SetImage(). Please create images with mode 'RGB' or convert first with image = image.convert('RGB'). Pull requests to support more modes natively are also welcome :)")

        if unsafe:
            #In unsafe mode we directly access the underlying PIL image array
            #in cython, which is considered unsafe pointer accecss,
            #however it's super fast and seems to work fine
            #https://groups.google.com/forum/#!topic/cython-users/Dc1ft5W6KM4
            img_width, img_height = image.size
            self.SetPixelsPillow(offset_x, offset_y, img_width, img_height, image)
        else:
            # First implementation of a SetImage(). OPTIMIZE_ME: A more native
            # implementation that directly reads the buffer and calls the underlying
            # C functions can certainly be faster.
            img_width, img_height = image.size
            pixels = image.load()
            for x in range(max(0, -offset_x), min(img_width, self.width - offset_x)):
                for y in range(max(0, -offset_y), min(img_height, self.height - offset_y)):
                    (r, g, b) = pixels[x, y]
                    self.SetPixel(x + offset_x, y + offset_y, r, g, b)

Nothing too funky yet – we’re in a .pyx which means we can use Cython to interface with C, but for now that’s not being used here. We can see what we’re trying to do here is default the implementation to use a faster, “unsafe” access. “Unsafe” typically implies we’re not making guarantees that the code won’t break, so one wonders why this is the default implementation to use… It’s at least good to know we can use unsafe=False to get around this deprecation, even if it’s slower.

Moving on to examine that unsafe function SetPixelsPillow():

    @cython.boundscheck(False)
    @cython.wraparound(False)
    def SetPixelsPillow(self, int xstart, int ystart, int width, int height, image):
        cdef cppinc.FrameCanvas* my_canvas = <cppinc.FrameCanvas*>self._getCanvas()
        cdef int frame_width = my_canvas.width()
        cdef int frame_height = my_canvas.height()
        cdef int row, col
        cdef uint8_t r, g, b
        cdef uint32_t **image_ptr
        cdef uint32_t pixel
        image.load()
        ptr_tmp = dict(image.im.unsafe_ptrs)['image32']
        image_ptr = (<uint32_t **>(<uintptr_t>ptr_tmp))

        for col in range(max(0, -xstart), min(width, frame_width - xstart)):
            for row in range(max(0, -ystart), min(height, frame_height - ystart)):
                pixel = image_ptr[row][col]
                r = (pixel ) & 0xFF
                g = (pixel >> 8) & 0xFF
                b = (pixel >> 16) & 0xFF
                my_canvas.SetPixel(xstart+col, ystart+row, r, g, b)

Alright! Now we’re in some interesting functionality. We’re definitely playing with low-level stuff now, and that means we need to cdef all the variables we’ll use at the top of the function (we can’t mix and match C and Python), so we’re defining a canvas object (which is native to rpi-rgb-led-matrix), setting up some variables for dimensions, position, color values, and most importantly image_ptr.

It should be pretty obvious that this pointer is a 2D buffer containing pixels in the image. We load this into a temporary (Python) pointer ptr_tmp using image.im.unsafe_ptrs – aha! our deprecated function! – before casting it finallly to uint32_t**. This code is running in mostly C, not Python, so it’s easy to imagine we’re probably getting pretty significant performance improvements with this method.

Now we know the fix is that we’ll need to find a way to get to a 2D uint32 array of pixel data without using the removed unsafe_ptrs call. It’s not worth looking at that call directly as it’s more or less just a Python wrapper returning a reference to the buffer that we just found. Instead, let’s look at the C header in Pillow, which shows where that buffer is located.

Here’s src/libImaging/Image.h @ Pillow 11.3.0

struct ImagingMemoryInstance {
    /* Format */
    ModeID mode; /* Image mode (IMAGING_MODE_*) */
    int type;    /* Data type (IMAGING_TYPE_*) */
    int depth;   /* Depth (ignored in this version) */
    int bands;   /* Number of bands (1, 2, 3, or 4) */
    int xsize;   /* Image dimension. */
    int ysize;

    /* Colour palette (for "P" images only) */
    ImagingPalette palette;

    /* Data pointers */
    UINT8 **image8;  /* Set for 8-bit images (pixelsize=1). */
    INT32 **image32; /* Set for 32-bit images (pixelsize=4). */

    // More things ...
}

Pretty straightforward stuff, but keep this in mind later as we’ll come back to it.

Implementing a Fix

Now that I knew where to look and what behavior to replicate, I started looking at how to actually do it. The deprecation warning noted that we could likely replace image.unsafe_ptrs() to image.im.getim(), so I started there.

This function signature isn’t super helpful…

    def getim(self) -> CapsuleType:
        """
        Returns a capsule that points to the internal image memory.

        :returns: A capsule object.
        """

        self.load()
        return self.im.ptr

I had to dig into what a CapsuleType represents since I’ve never worked with it before… Essentially, in this case it’s a PyCapsule, which is more or less a container for a C pointer, and this capsule contained a pointer to the ImagingMemoryInstance we saw before. That sounds promising! I thought this would be pretty straightforward after finding this.

Instead, I hit a fairly major roadblock. My strategy was pretty straightfoward:

Import the ImagingMemoryInstance struct from Pillow into the Python script
Read the pointer from the capsule and cast it to the struct
Read image.image32 directly

What actually happened was Cython totally choked reading the header I needed:

# doesn't work because Cython can't handle typedef *
cdef extern from "Imaging.h":
    cdef struct ImagingMemoryInstance:
        pass # Filled out from header

Cython is a compiler, and Pillow has some quirky old C code. It seems like it was blowing up on structs like the following, but I’m not totally sure. Either way, it wasn’t working, so I needed another solution

typedef struct ImagingMemoryArena {
  // members
} *ImagingMemoryArena;

Without that struct that I need, I can’t get the byte offset to the buffer that SetImage() is expecting. And I really don’t want to hardcode the offset, as that would be quite brittle. I briefly explored that option, but noted that the implementation of the first member (mode) hasn’t changed in probably a decade – right up until it did within the last few months.

The Workaround

Rather than use Cython to try to handle the import, I wrote a really simple shim that does this for us. The header sets up a named struct and declares a function get_image32() – note that it accepts a raw pointer!

#ifndef SHIMS_PIL_H
#define SHIMS_PIL_H

#ifdef __cplusplus
extern "C" {
#endif

typedef struct ImagingMemoryInstance ImagingMemoryInstance;

int** get_image32(void* im);

#ifdef __cplusplus
}
#endif

#endif

But now, the function definition accepts the pointer to the ImagingMemoryInstance we need, and we pull in Imaging.h from Pillow, which should contain exactly the struct needed!

#include "Imaging.h"
#include "pillow.h"

int** get_image32(void* im) {
    ImagingMemoryInstance* image = (ImagingMemoryInstance*) im;
    return image->image32;
}

And it turns out this works pretty well! There’s a little bit left to glue together at this point, mainly just getting the pointer from the capsule (which you must do by name). I also wrote a helper method to pull out the buffer. Like I mentioned before, in functions that interface with both C and Python, you can’t intermingle Python variables before C variables, so these helpers are useful to make the code a bit more manageable.

cdef extern from "Python.h":
    void* PyCapsule_GetPointer(object capsule, const char* name)
    const char* PyCapsule_GetName(object capsule)

cdef extern from "shims/pillow.h":
    cdef int** get_image32(void* im)

@cython.boundscheck(False)
@cython.wraparound(False)
cdef int** get_pillow_buffer(object capsule):
    cdef void *image

    image = PyCapsule_GetPointer(capsule, PyCapsule_GetName(capsule))

    return get_image32(image)

And finally, the last bit is to simply drop in the new buffer lookup in the unsafe SetImage() function. As expected, this part is really straightforward. Also of note here is that the function now requires the capsule directly, rather than reading it from the Pillow image object. This is, again, due to the fact that calling image.getim() is a Python function and thus, needs to happen after C definitions. By passing it in the parameters, we don’t have to declare it at all, simplifying things.

    @cython.boundscheck(False)
    @cython.wraparound(False)
    def SetPixelsPillow(self, int xstart, int ystart, int width, int height, object image_capsule):
        cdef cppinc.FrameCanvas* my_canvas = <cppinc.FrameCanvas*>self._getCanvas()
        cdef int frame_width = my_canvas.width()
        cdef int frame_height = my_canvas.height()
        cdef int row, col
        cdef uint8_t r, g, b
        cdef int **buffer
        cdef int pixel

        buffer = get_pillow_buffer(image_capsule)

        for col in range(max(0, -xstart), min(width, frame_width - xstart)):
            for row in range(max(0, -ystart), min(height, frame_height - ystart)):
                pixel = buffer[row][col]
                r = (pixel ) & 0xFF
                g = (pixel >> 8) & 0xFF
                b = (pixel >> 16) & 0xFF
                my_canvas.SetPixel(xstart+col, ystart+row, r, g, b)

Wrap Up

Here’s the final merged PR for reference. I hope you found this as interesting as I did – I did not expect to need to write a C shim to get this working, but after it’s all said and done I’m happy with the way it turned out and several others have independently verified the work.

I feel like I have a better understanding (although certainly not complete) of how Python can interface with C/C++ code. It’s a little cumbersome to get used to, but given the performance improvements it can drive, it’s totally worth it.

That’s all for now. Thanks for reading!

Photographic tools

Blogs on Michail Rybakov — Fri, 07 Nov 2025 16:07:46 GMT

I’ve started designing custom film cameras, and needed tools to understand what kind of tolerances and imperfections can I get away with when guessing focusing distances. And more importantly, what kind of image would a lens create, and how the field of view, depth of field, focal length and aperture would correspond across different film formats. I haven’t really found good tools online, so I created some myself. Hope they can help someone:

Circle of Confusion Calculator
This one shows what would be in focus and how front/back blur behaves across formats. It was really eye-opening for me to play with it and understand the relationships between the different factors and how they shape the image. The Circle of Confusion tells us what a point light source turns into after going through the lens. It is basically the brush with which you paint light. And at different film formats (at similar image viewing distances), similar sized CoC might appear to paint a sharp or a blurry picture. Play with the tool to find out more!

Background Blur Accumulation Calculator
This one shows background blur accumulation at different format and apertures, to see what lens you would need in e.g. 35mm to simulate a LF look. In this case specifically an abstract measure of “how much blur will there be for 2 meters behind the focus point”. It was created specifically for environmental portraits and uses vertical angle of view (instead of, as often used, the diagonal) to get a better feeling of background separation in portraits. It tries to help you with the questions of “Where should I place the person?” and What lens and what aperture should I use for better background separation?"

Helicoid Extension Calculator
This one shows your helicoid/focusing rail extension across focal lengths and focus distances.

Distance Scale Creator
This one is for creating a distance scale and printing it out at home.

All of them are interactive, so play around and see how it all relates. Let me know if somethings is not working as expected!

A Man Called Otto: An omen to a simple but fulfilling life

🦉 olshansky 🦁 — Fri, 07 Nov 2025 08:16:21 GMT

Olshansky's review of A Man Called Otto

Novel idea in vector search: Wormhole vectors

Stories by Dmitry Kan on Medium — Fri, 07 Nov 2025 08:04:55 GMT

Vector Podcast episode: educational bit

Two weeks ago I had a pleasure to co-host a lightning session together with Trey Grainger on a novel idea in vector search called “Wormhole vectors”.

The approach contrasts itself to a hybrid search approach.

In hybrid search you would convert the same input query into different representations (keywords -> embeddings), run independent queries, and then combine the results.

Wormhole vectors opens a new way to transcend vector spaces of different nature:

Query in the current vector space
Find a relevant document set
Derive a “wormhole” vector to a corresponding region of another vector space
Traverse to the other vector space with that query
Repeat as desired across multiple traversals

More specifically, if you come from a sparse space, taking a set of returned documents you can pool their embeddings into one embedding and use it as a “wormhole” into the dense vector space.

If as input you are dealing with a set of embeddings from a vector search, you can traverse the Semantic Knowledge Graph (SKG) to derive a sparse lexical query best representing these documents.

Recording:

https://medium.com/media/8a370f3d907611a20eb3479395bf29c1/href

What you’ll learn:

What are “Wormhole Vectors”?

Learn how wormhole vectors work & how to use them to traverse between disparate vector spaces for better hybrid search.

Building a behavioral vector space from click stream data

Learn to generate behavioral embeddings to be integrated with dense/semantic and sparse/lexical vector queries.

Traverse lexical, semantic, & behavioral vectors spaces

Jump back and forth between multiple dense and sparse vector spaces in the same query

Advanced hybrid search techniques (beyond fusion algorithms)

Hybrid search is more than mixing lexical + semantic search. See advanced techniques and where wormhole vectors fit in.

Find this episode on many popular platforms:

Spotify: https://open.spotify.com/episode/3fvfbAGQREqCJeUciyRb3r

Apple Podcasts: https://podcasts.apple.com/fi/podcast/trey-grainger-wormhole-vectors/id1587568733?i=1000735675696

RSS: https://rss.com/podcasts/vector-podcast/2314900/

Tuning TLS: AES-256 Beats ChaCha20 on Every CPU

Ash's Blog — Fri, 07 Nov 2025 02:00:00 GMT

AES-256-GCM now beats ChaCha20-Poly1305 by up to 3x on every modern CPU with hardware acceleration, reversing the 2015 mobile performance advice.

Placebo Emporium: 2025 Annual Shareholder Letter

taylor.town — Fri, 07 Nov 2025 02:00:00 GMT

the world's finest placebos at affordable wholesale prices

The Impossible Triangle of LLM Infra

swyx's site RSS Feed — Thu, 06 Nov 2025 21:47:03 GMT

another talk I am giving at Mastra's TypeScript AI conf today https://docs.google.com/presentation/d/1NnQ3H5Bki3vWRRJdVXoCFJ5dsNKH9QrC-eEQ2Z8olck/edit?usp=sharing

Solarpunk is already happening in Africa

Nicola Iarocci — Thu, 06 Nov 2025 18:43:31 GMT

Super interesting.

What’s happening across Sub-Saharan Africa right now is the most ambitious infrastructure project in human history, except it’s not being built by governments or utilities or World Bank consortiums. It’s being built by startups selling solar panels to farmers on payment plans. And it’s working.

Why Solarpunk is already happening in Africa

The ongoing discussion on HN is also worth reading (minus the AI slop complaints).

Material for MkDocs Is No More! Long Live Zensical!

DevLog — Thu, 06 Nov 2025 15:12:08 GMT

As of November 5th, 2025, Material for MkDocs is now in maintenance mode, with committed support for the next 12 months. At the same time a new static site generator (SSG) has been brought to live, with a faster build engine and maximum compatibility with MkDocs (for now), and built with the same open source […]

RSpec and `let!`: Understanding the Potential Pitfalls

All about coding — Thu, 06 Nov 2025 10:27:35 GMT

Avoid using `let!` in RSpec tests and discover alternative approaches to increase test readability and debugging

The day IPv6 went away

./techtipsy — Thu, 06 Nov 2025 06:00:00 GMT

Well, that's a first.

Fetch The Flag 2023 Beep64 Writeup

Justus Perlwitz — Thu, 06 Nov 2025 02:00:00 GMT

This is a writeup for the Fetch The Flag 2023 Beep64 challenge.

1290

Ellie's Notes — Thu, 06 Nov 2025 02:00:00 GMT

Ellie's 1290 Superduke R Evo

I moved to the US and bought a superduke yay

Here I am making some notes. I will likely also track torque specs, services, etc.

Specs

A collection of useful specs

Spec	Value
Factory recommended rear pressure	42
Factory recommended front pressure	36
Ellie's preferred rear pressure	36
Ellie's preferred front pressure	32

Torque specs

I'll note them down as I look them up

Part	Torque (nm)
Rear wheel nut	250

Bolt sizes

Still Blogging This

jonandnic dot com — Wed, 05 Nov 2025 16:14:42 GMT

This site has been online, in one form or another, for 25 years. Still, I took all but a landing page down for the move, and debated about whether it should return at all...

Backing up my repositories to self-hosted Gitea

Igor Kulman — Wed, 05 Nov 2025 06:29:12 GMT

I’ve been gradually moving more of my setup to self-hosted services. After turning my old ThinkPad into a home server, one of the next logical step was to back up all my Git repositories. Most of my projects live on GitHub, and other places I use for contract work. For a while, I just ran an rsync backup of my local clones. It worked, but it wasn’t a real solution — no metadata, no browsing, and no way to restore easily.

How the Calm app slowly won me over

Ananth's Reflections — Wed, 05 Nov 2025 03:09:41 GMT

The Beginning

Bending Emacs - Episode 5: Ready Player Mode

xenodium.com @alvaro — Wed, 05 Nov 2025 02:00:00 GMT

I'm now a bit over a month into my Emacs video-making journey. Today I bring a new episode.

Bending Emacs Episode 5: Ready Player Mode

Having migrated to mostly playing offline music, in this episode I show how to use Ready Player Mode (a package I built) for this purpose.

This is what my Ready Player configuration mostly looks like:

(use-package ready-player
  :ensure t
  :custom
  (ready-player-my-media-collection-location "~/Music/Music/Media.localized/Music")
  :config
  (ready-player-mode +1))

Note that ready-player-mode adds a global C-c m, which is https://github.com/xenodium/ready-player?tab=readme-ov-file#global-key-bindingsh

On macOS, I have one additional bit to tweak button icons to use SF Symbols. You'll need to tweak your fonts too.

(set-fontset-font t nil "SF Pro Display" nil 'append)
(ready-player-macos-use-sf-symbols)

On a related blog post, I gave a tour of Ready Player Mode.

In the video, I also mentioned dired buffers are at the heard of Ready Player. My dired abstraction post shows how to programmatically craft a valid dired buffer. Spoiler alert, it's pretty simple:

(let ((default-directory "/absolute/path/to/Music/George Benson"))
  (dired '("*My fancy m3u list*"
           "Body Talk/01 Dance.mp3"
           "Body Talk/02 When Love Has Grown.mp3"
           "Body Talk/03 Plum.mp3"
           "Original Album Classics/1-01 So What.mp3"
           "Original Album Classics/1-02 The Gentle Rain (From the Film, _The Gentle Rain_).mp3"
           "Original Album Classics/1-03 All Clear.mp3"
           "The Shape Of Things To Come/01 Footin' It.mp3"
           "The Shape Of Things To Come/02 Face It Boy It's Over.mp3"
           "The Shape Of Things To Come/03 Shape Of Things To Come.mp3")))

Hope you enjoyed the video!

Want more videos?

Liked the video? Please let me know. Got feedback? Leave me some comments.

Please go like my video, share with others, and subscribe to my channel.

If there's enough interest, I'll continue making more videos!

Make it all sustainable

Enjoying this content or my projects? I am an indie dev. Help make it sustainable by ✨sponsoring✨

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

A few months with htmx

Thomas Hunter II — Wed, 05 Nov 2025 02:00:00 GMT

Photos from November 5th, 2025

cjlm.ca — Wed, 05 Nov 2025 02:00:00 GMT

Rust after six months: my impressions on language features, tooling and ecosystem

Bruno Croci — Wed, 05 Nov 2025 02:00:00 GMT

Rust is only around ten years old, but it already made a huge impact in the software community. It went as far as making it into the Linux Kernel! The meme ‘written in Rust, btw’ is often joked about, but in reality, it’s inspiring many people to create interesting innovations in established domains.

Think of tools like uv for Python; deno for Javascript; modern terminal emulators like alacritty and wezterm; a modern shell, fish; text/code editors like zed and helix; a new browser engine servo; even gamedev with the highly experimental 100% data-driven game engine bevy. The new wave of remake of classic unix tools, such as bat (for cat), ripgrep (grep), yazi (tui file manager), eza (ls), zellij (screen/tmux), etc. There are a lot of implications of creating a modern version of these tools, because they’re doing one thing very well (as the unix philosophy), but also they’ve been doing the very same thing for half a century. Rust is bringing more diverse people to the realm of systems programming. People with fresh ideas and different concepts about what it means to use a computer. Not necessarily better, but different.

I also joined the trend of rewritten in Rust and created bulletty, a TUI feed reader. And it’s been six months since I’ve been learning this language and this post is a collection of notes on parts of it that I find interesting.

My first experience with it

Back in 2019, I started doing the Ray Tracing in One Weekend series of books in Rust, at the same time I was reading The Rust Programming Language book. I did get something out of it, I think I finished the first raytracing book entirely.

It didn’t get me really hooked, but I think it has more to do with what was happening in my life at the moment, I was going through some depression, I had just moved countries and it was my first European winter. Coming straight from a place where it’s summer every single day of the year.

a basic raytracer written in Rust

I moved on, but I wanted to try more at some point.

Crate ecosystem

I want to start off with the crate ecosystem. If you’re not familiar with it, Rust has a very complete build system with a package/dependency manager in it, cargo. With it, you can very easily include 3rd party libraries, or crates, into your project, something very similar to npm in Javascript, or pip in Python. But it’s the first time I’ve see a dependency manager work so well in a compiled language. For C++, there’s conan, vcpkg and cpm, or even pure CMake’s FetchContent, but honestly it’s a pain to get it working seamlessly.

It’s really convenient to look for “Perlin Noise” and just include the first crate you find that will provide you with the needed functions. However, there are problems with it, such as dependencies that rely on other dependencies that may not fit your project for a variety of reasons such as license or simply because another of your dependency also require that dependency, but in another version. For example, bulletty explicitly declares 27 dependencies at the moment, but considering all the necessary dependencies to build it, it goes to an outstanding number of 366!

That means there’s just so much code running when you fire up bulletty that I’ll never be able to audit. On the other hand, it’s thanks to them that bulletty was made possible. I honestly don’t think I would have gotten that far if I had to parse HTML into Markdown myself, it’s too big of a mountain to climb when you’re starting a project. Now I’m customizing parts of the crate that does that. :)

Algebraic Data Types & Pattern Matching

Pattern Matching is one of my favorite language features. It’s really expressive and convenient to describe exactly what you’re trying to compare, for example:

match x { 
	1 => println!("one"),
	2 => println!("two"), 
	3 => println!("three"), 
	4 => println!("four"), 
	5 => println!("five"), 
	_ => println!("something else"), 
}

That example of course is very similar to a switch-case expression, but what now?

match ph { 
	0..7 => println!("acid"), 
	7 => println!("neutral"), 
	8..=14 => println!("base"),
	_ => unreachable!()
}

Examples were taken from Rust Reference.

But this gets way more exciting when you combine these with an Algebraic Data Type, such as Rust Enums:

enum IpAddr {
	V4(u8, u8, u8, u8),
	V6(String), 
}
 
let home = IpAddr::V4(127, 0, 0, 1); 
let loopback = IpAddr::V6(String::from("::1"));

//...

match ip {
	V4(ip1, ip2, ip3, ip4) => println("You IP is: {}.{}.{}.{}", ip1, ip2, ip3, ip4),
	V6(ipv6) => println!("Your IP is: {}", ipv6);
}

Since IpAddr can be either a V4 or an V6, and they hold different information, you can match the type and bind variables for the data needed. If you ever did any Haskell, OCaml or Scala, you’d be smiling now.

Error handling

I always hated try...catch constructs in C# and Java. First because the way it looks, several blocks of try with multiple lines within it, followed by lots of catch seemed very hard to read in my opinion. Not to mention that it’s not always obvious some function will thrown an exception, completely breaking the flow of the program. In C++, I absolutely never used it.

Rust offers very robust mechanisms to handle errors. Functions can return a Result<Type, Error> monad, similar to Option<Type>, containing either Ok(T) or Err(E), which makes it instantly clear how to deal with the result. Plus, there’s a lot of syntactic sugars that help the code get more readable while still safe. For example, the ? operator:

fn do_something() -> Result<(), Error> {
	let test = get_some_value()?;
	let another_test = test.get_something_else()?;
	another_test.do_something()
}

The ? operator redirects the result of a function call to the return of the current function, effectively delegating the obligation to check errors to the caller of do_something(). That way, you can call several functions that will themselves return a result and not worry for that at that moment.

The good things about the Result type don’t stop there. It includes functions for quick testing such as is_error(), or to transform into another error type with map_err, and since it’s just another value, you can pattern match it when you want to treat it. The easiest way to error checking that function above is:

if let Err(my_error) = do_something() {
	println!("Oops, I got this error: {:?}", my_error);
}

Returning

In Rust, it will automatically return the last value in the block, so you can have a function like:

fn double(x: i32) -> i32 { x * 2 }

No need to add ; at the end of a return value, which makes it instantly recognizable.

Since any block can return, it’s simpler to attribute conditional values to variables with if or match, for example:

// almost like a ternary operator
let i: Option<i32> = if b == 2 { 
	let z: i32 = b * 20;
	Some(z)
} else { 
	None 
};

// pattern matching returns values!
let z: i32 = match i {
	None => 0,
	Some(v) => v,
};

Or even cooler, just regular blocks:

let i: i32 = {
    let b = 42 * 3;
    b
};

And considering Rust objects only live during their own scope, creating limited blocks like this is more useful to keep your memory in control.

Compiler messages are fantastic

Rust is a bureaucratic language, purposely. Its memory allocation/deallocation model, binding heap memory to their scopes, creates a lot of friction to programmers used to either languages that deals with garbage, or languages that expects you to do your chores. But it does by shifting all that responsibility to the compiler. It’s frustrating, but the messages the compiler and the linter give you are really detailed, often explaining the issue and suggesting fixes.

Best LSP

As a professional C++ and C# programmer, I’m very used to Visual Studio, which in general index really well the symbols in the projects and offers several functionalities to help you navigate in a large codebase. So far, I haven’t found a single LSP that offered a similar experience to Visual Studio (or other big IDEs), something like detecting types well, finding definitions in other files, suggesting and applying changes in code, reliably renaming fields and functions, etc. But it changes with the Rust LSP. It’s very complete and works incredibly well with Neovim, for example.

Of course, it helps that the language has a static type system and a relatively simple build system. For example, C++ has types, but building and linking is a whole nightmare. So many possible ways to build a project in C++, with different compilers, different linkers, different runtimes, that I can understand if no LSPs will ever be really good. On the other hand there’s Python or Javascript, where the runtime just need to make dependencies available and run it, but their type system is basically non-existent.

Rust’s LSP is aware of the whole project, it finds definitions really quick, it allows for symbols renaming, it resolves use directives, it displays API documentations within the editor (and even lets you open the API code directly) and it gives lots of suggestions to improve code. I see some people shitting on LSPs because “you’re supposed to know your codebase”, as if auto-completions were even the most important thing in it.

But beware the LSP consumes a lot of system resources. I was trying to program rust on a VPS with only 2GB of RAM and it was a bit challenging. Constantly crashing. Good thing I got a much beefier VPS now.

Compile times are long

It’s a common issue, the compiler is slow. Building bulletty from scratch takes around a minute. LSP boot-up time when I open neovim is a bit longer that I would like. But honestly nothing that really annoys me. Just a consideration.

use directives can get a bit confusing sometimes

You open a Rust source code and first thing you see is this.

use directive hell

Tell me if you don’t find it a bit confusing. I’m coming from the C++ realm where you can easily find 75 lines of #include "../../module/test/foo.h in the beginning of the file, but at least it’s instantly recognizable. All the nesting modules imports in Rust look almost like code, so it’s hard to find where code actually starts. I’m glad the LSP usually handles that for me.

Conclusion

I feel like Rust is a perfect example of a modern language with very good tooling that can build fast, safe natives without a lot of hassle. Easy to start prototyping with 3rd party libraries, beautifully portable, fast and safe. It brought people from the C++-land and the Ruby-land together, it made it to the Linux kernel. Of course, it’s not all flowers. The language can be a little complicated to get started with because of the borrow-checker, and it’s a rather complicated language with lots of features, but for many domains, it can be almost like coding in python or javascript.

Skills for the Future

Ecce Homology on Bastian Grossenbacher Rieck's personal homepage — Tue, 04 Nov 2025 22:00:00 GMT

Barring a major “Mad Max” type scenario (which would anyway make all our hard-earned skills obsolete) recent discussions lead me to believe that one of the key skills in the future will be the ability to communicate concisely. We could call it “cutting through the BS” or “anti-slop vision,” but it appears to me that the future is not likely to belong to those who wield AI like a vorpal sword, puffing up every little idea into the intellectual equivalent of cotton candy, but rather those who use it reluctantly—if at all.¹

I am basing this on a fundamental observation, viz., the deluge of AI-based slop I am receiving on a nigh-daily basis, mostly in the form of applications. All of them break the cardinal rule of writing, which states that you must have something to say in order to write. In fact, I like to summarize writing as “simple”² two-step process:

Have something to say.
Say it.

LLMs make it easier for people to clothe their content better, but unless their users show some restraint, LLMs will always err on the side of flattery and purple prose without any additional content. Hence, if you have nothing to say, you may now say it nicer and with more words. Surely, that is precisely what we have been waiting for!

That is not to say that I am against the use of LLMs, on the contrary. But this post is less about how to use LLMs gainfully, a skill that any person with intact critical faculties³ can figure out, and more about a skill that will retain its relevance. Indeed, the ability to read between the lines, perceive the actual content (be it ever so hidden), and strip away everything that is unnecessary may well be the best tool in any person’s intellectual toolbox. Coupled with critical thinking, anyone thus equipped will be able to navigate the world of tomorrow, which, if we are not very careful, will be swamped even more with bogus content.

This is not your standard “cultural pessimism” post; I am actually quite hopeful about the future insofar as slop and low-quality content has always been with us. The fact that we can now mass-produce it is deplorable but also provides ample opportunities to hone one’s intellectual abilities. And who knows, maybe we will soon move beyond inane cotton-candy content and use LLMs in domains to which they can actually contribute?

Here’s to hoping, until next time!

Do not let the em-dash fool you. I have been using them long before the advent of LLMs, and, fortune willing, I shall continue using it long after these models have gone the way of the dodo. ↩︎
Following the grand tradition of beloved mathematics textbooks here. ↩︎
The interesting question is to what extent the critical faculties remain with prolonged reliance on what one may call, somewhat hyperbolically, intellectual crutches. ↩︎

You’re absolutely right! GoPro’s support is just AI Slop

Something Decent — Tue, 04 Nov 2025 19:50:26 GMT

I recently bought myself a new GoPro to complete some promo work for a project. When I had gotten it home I unpacked it, excited to test it out. You see, it has been a while since I last used any sort of action camera (the last one I broke within a few minutes of […]

The post You’re absolutely right! GoPro’s support is just AI Slop appeared first on Something Decent.

Quest for Permissively Licensed PDF Library in C#

DevLog — Tue, 04 Nov 2025 11:12:00 GMT

From my experience, every product will eventually want to export some messages or generate a report and it obviously needs to be a PDF. Primarily working with C# these days, it’s a recurring quest to find a good PDF rendering solution for .NET. Quest Unlocked! Naturally, I first started looking for permissively licensed libraries, which […]

A Project Is Not a Bundle of Tasks

Second Thoughts — Tue, 04 Nov 2025 02:33:14 GMT

Current AIs struggle to create a whole that exceeds the sum of its parts

agent-shell 0.17 improvements + MELPA

xenodium.com @alvaro — Tue, 04 Nov 2025 02:00:00 GMT

While it's only been a few weeks since the last agent-shell post, there are plenty of new updates to share.

What's agent-shell again? A native Emacs shell to interact with any LLM agent powered by ACP (Agent Client Protocol).

Thank you sponsors

Before getting to the latest and greatest, I'd like to say thank you to new and existing sponsors backing my projects.

While the work going in remains largely unsustainable, your contributions are indeed helping me get closer to sustainability. Thank you!

If you benefit from my content and projects, please consider sponsoring to make the work sustainable.

More productive at work?

Work paying for your LLM tokens and other tools? Why not get your employer to sponsor agent-shell also?

MELPA

Now on to the very first update… Both agent-shell and acp.el are now available on MELPA. As such, agent-shell installation now boils down to:

(use-package agent-shell :ensure t)

New providers

OpenCode and Qwen Code are two of the latest agents to join agent-shell. Both accessible via M-x agent-shell and M-x agent-shell-new-shell through the agent picker, but also directly from M-x agent-shell-opencode-start-agent and M-x agent-shell-qwen-start.

Send files - Thanks to Ian Davidson

Adding files as context has seen quite a few improvements in different shapes. Thank you Ian Davidson for contributing embedded context support.

Send screenshots

Invoke M-x agent-shell-send-screenshot to take a screenshot and automatically send it over to agent-shell.

Activity Indicator

A little side-note, did you notice the activity indicator in the header bar? Yep. That's new too.

@ completion (experimental)

While @ file completion remains experimental, you can enable via:

(setq agent-shell-file-completion-enabled t)

Send files or regions

From any file you can now invoke M-x agent-shell-send-file to send the current file to agent-shell. If region is selected, region information is sent also. Fancy sending a different file other than current one? Invoke M-x agent-shell-send-file with C-u prefix, or just use M-x agent-shell-send-other-file.

Send `dired` files

M-x agent-shell-send-file, also operates on dired files (selection or region), DWIM style ;-)

Shorter paths in titles

You may have noticed paths in section titles are no longer displayed as absolute paths. We're shortening those relative to project roots.

Shell creation / handling

While you can invoke M-x agent-shell with C-u prefix to create new shells, M-x agent-shell-new-shell is now available (and more discoverable than C-u).

Cancelling sessions

Cancelling prompt sessions (via C-c C-c) is much more reliable now. If you experienced a shell getting stuck after cancelling a session, that's because we were missing part of the protocol implementation. This is now implemented.

Shell commands

Use the new M-x agent-shell-insert-shell-command-output to automatically insert shell (ie. bash) command output.

Markdown transcripts (experimental) - Thanks to Elle Najt

Initial work for automatically saving markdown transcripts is now in place. We're still iterating on it, but if keen to try things out, you can enable as follows:

(setq agent-shell--transcript-file-path-function #'agent-shell--default-transcript-file-path)

Configuration

Turn off ASCII welcome banners

(setq agent-shell-show-welcome-message nil)

Turn off graphical header

Text header

(setq agent-shell-header-style 'text)

No header

(setq agent-shell-header-style nil)

Inline display of historical changes - Thanks to Elle Najt

Applied changes are now displayed inline.

Session mode - Thanks to Elle Najt

The new M-x agent-shell-cycle-session-mode and M-x agent-shell-set-session-mode can now be used to change the session mode.

Agent capabilities

You can now find out what capabilities and session modes are supported by your agent. Expand either of the two sections.

Accepting/rejecting changes from diff buffer

Tired of pressing q and y to accept changes from the diff buffer? Now just press y from the diff viewer to accept all hunks.

Same goes for rejecting. No more q and n. Now just press C-c C-c from the diff buffer.

Transient menu

We get a new basic transient menu. Currently available via M-x agent-shell-help-menu.

Contributions

We got lots of awesome pull requests from wonderful folks. Thank you for your contributions!

Arthur Heymans: Add a Package-Requires header (PR).
Elle Najt: Execute commands in devcontainer (PR).
Elle Najt: Fix Write tool diff preview for new files (PR).
Elle Najt: Inline display of historical changes (PR).
Elle Najt: Live Markdown transcripts (PR).
Elle Najt: Prompt session mode cycling and modeline display (PR).
Fritz Grabo: Devcontainer fallback workspace (PR).
Guilherme Pires: Codex subscription auth (PR).
Hordur Freyr Yngvason: Make qwen authentication optional (PR).
Ian Davidson: Embedded context support (PR).
Julian Hirn: Fix quick-diff window restoration for full-screen (PR).
Ruslan Kamashev: Hide header line altogether (PR).
festive-onion: Show Planning mode more reliably (PR).

Lots of other work ❤️😅

Beyond what's been showcased here, much love and effort's been poured into polishing the agent-shell experience. Interested in the nitty-gritty? Have a look through the 173 commits since the last blog post.

Support this work

If agent-shell or acp.el are useful to you, please consider sponsoring its development. LLM tokens aren't free, and neither is the time dedicated to building this stuff ;-)

Fetch The Flag 2023 Finders Keepers

Justus Perlwitz — Tue, 04 Nov 2025 02:00:00 GMT

This is a writeup for the Fetch The Flag 2023 Finders Keepers challenge.

USDA Prohibits SNAP Discounts

Light of Reason — Tue, 04 Nov 2025 01:24:25 GMT

p>The U.S. Department of Agriculture has told grocery stores they cannot offer special discounts to...

State-by-State Expected SNAP Benefit Delay Breakdown

Light of Reason — Tue, 04 Nov 2025 01:22:04 GMT

With the federal government issuing only partial SNAP benefits for November and state systems scrambling...

Partial SNAP Benefits for November

Light of Reason — Tue, 04 Nov 2025 01:20:15 GMT

Millions of households are bracing for reduced food assistance this month as the federal government...

Are People Getting Their SNAP Benefits?

Light of Reason — Tue, 04 Nov 2025 01:16:58 GMT

The Supplemental Nutrition Assistance Program (SNAP) provides monthly financial assistance to help low-income individuals and...

What if software shipped with a software engineer?

Home on The Log Book of Manuel Kießling — Tue, 04 Nov 2025 00:00:01 GMT

A recent experiment made the rounds showing an LLM acting as the whole application: every HTTP request is handled by the model, that designs schemas, renders HTML, and mutates state through tool calls: “Why write code if the LLM can just do the thing?”. It worked — barely. It was slow, expensive, and visually inconsistent. But it surfaced a useful question: if inference keeps getting cheaper and faster, why generate code at all?

The devil is in the defaults...

Fabian's public notepad — Mon, 03 Nov 2025 22:50:00 GMT

Recently a bugfix at work reminded me of a story from ages ago, and a small, yet important lesson on the importance of defaults in API design, that I took away from it.

So, back in the days, when commuting to work was some kind of bad default most of us were stuck to for no apparent reason, we merrily programmed forms, using a happy little in-house component library. And like any proper component library, this particular one came with a special company-custom button, for merely slapping CSS classes on a plain HTML <button> element and calling it a day is beneath the dignity of serious enterprise APIs.

Back then the company employed a small tribe of shamans (they called themselves designers, but I suspect mostly just because they had rent to pay and shaman is not considered a cromulent job title in an enterprise email signature) who in their unerring wisdom handed out guidelines for the enlightening and overall betterment of the world. These guidance foresaw that buttons shall come in many variations. Amongst them such that were to be used for finalizing actions, and such for destructive actions (with a red background, as if to menacingly say click me, oh user, if you dare), or those that looked like an ordinary link, but clicking them only performed sideffects on the very same page (the only page to be exact, because, like all civilized folks in 2010s, we built single-page apps). And, last but not least, the garden-variety of for all other commands of secondary importance that the toolbar of an enterprise application might want to offer to be invoked.

Meanwhile, a different tribe, the sages of software architecture, in their sisyphean quest to herd the developers (which you can herd pretty much the same way as you herd a glaring of wild cats), became a bit agitated. They feared the notion of creative interpretation of the shamans' guidelines. To prevent anarchy by means of committee steered standardization, one of their young'uns was charged with the creation of the aforementioned library, so that all code bases, just like all happy families, in the end would be alike (the Anna Karenina principle of API design), and each button that would save a form might have resembled something like this (and made damn sure that nobody did something crazy like just using a button!):

<special-company-button id=saveCmd variation=finalize>
Save
</special-company-button>

Everything hummed along quite fine, and the garden-variety, to the suprise of no-one, was by some margin the most common variation. That was why in the initial implementation it was chosen as the default value for the variation. That was what naive younger me thought at least, until that fateful day, when the maintainer of that special-company-button component, with the impeccable reasoning that the most important thing on any form to do was to finally submit it, decided that the default variant henceforth should be finalize. No big deal. A one liner, changed, committed and released as a minor version somewhere between a late standup and the lunch break.

Well, semantic versioning, my sweet behind... No amount of reasoning helped to roll that change back. So, all usages of that component without specific value set (suffice to say, quite a few...) had to be touched again.

Joshua Bloch, the mind behind some of the most used APIs in the Java ecosystem, has a great talk on How to Design a Good API and Why it Matters (PDF) and a condensed set of maxims for API design, one of which I felt particularly strong that day (and ever since):

Public APIs, like diamonds, are forever. You have one chance to get it right so give it your best.

Good defaults reduce cognitive load, and make the most common use cases easy. The best details are those where you (most of the time) don't have to spend brain cycles on. And even seemingly small semantically incompatible changes in widely used public API have a huge impact. Defaults ought to be trustworthy. Primitive value changes are something that a type system usually does not catch (unlike renaming a package or class, or changing a method signature), updating feels smooth and leave you with a silently broken UI at run time. To drive the point home: Default values are public APIs. Handle with care.

"You Don't Need Kafka, Just Use Postgres" Considered Harmful

Gunnar Morling — Mon, 03 Nov 2025 19:02:00 GMT

Looking to make it to the front page of HackerNews? Then writing a post arguing that "Postgres is enough", or why "you don’t need Kafka at your scale" is a pretty failsafe way of achieving exactly that. No matter how often it has been discussed before, this topic is always doing well. And sure, what’s not to love about that? I mean, it has it all: Postgres, everybody’s most favorite RDBMS—check! Keeping things lean and easy—sure, count me in! A somewhat spicy take—bring it on!

Roast #47: Home coffee bar

thoughtfulcoffee — Mon, 03 Nov 2025 16:43:32 GMT

Nobody should ever have 3 foldable steel tables in their nyc apartment

How to strengthen your attention

Ananth's Reflections — Mon, 03 Nov 2025 15:08:02 GMT

I recently listened to a podcast from Mel Robbins with Dr.

Fixing LCD Screen Corruption of a Tektronix TDS220 Oscilloscope

Electronics etc… — Mon, 03 Nov 2025 12:00:00 GMT

Creating my own models for 3D printing

kleemans.ch — Mon, 03 Nov 2025 11:00:45 GMT

Last year in April, I got myself a Creality Ender 3 V3 SE 3D printer.

It was a steep learning curve at first - after learning about leveling (apparently needed from time to time), z-offset (not the same as leveling), different filaments (regular PLA works fine for my printer, wooden PLA not so much) and over-extrusion (apparently the case for my printer), I continued to make progress on getting the prints I wanted.

Now a great way to get started were the various pages which provide models like Thingiverse. In the beginning, I was really printing a lot of what I just randomly stumbled upon or what I thought might be handy or fun. After printing the 7th or so fidget toy I started to wonder, how difficult would it be to design my own models?

My first attempts were with Sketchup to replace a piece for a Hexagon puzzle, but after getting the dimension wrong (radius and diameter, aren't they almost the same?) and having to redo the whole thing, I learnt about parametric modelling, which just is a really great thing™, so I started out learning Onshape.

Train tracks (3x)

After watching a tutorial video about Onshape, I think one of my first designs was a train track. We have a BRIO train track system at home, so it was a nice entry point to measure a train track and trying to replicate it as a 3D model.

It was really new to me, but an interesting thought process: How can I replicate a shape? For example, start out with a rectangle, add a circle to it, and cut away another small rectangle to get the part where the train tracks can be connected:

I find it fascinating that with a few constraints, you can define most of your layout. In Onshape, you can define constraints like two lines being of equal length, a point being in the middle of a line, etc.:

Along the way, you also learn about the real-world model you're studying. For example, did you know that train tracks have V-shaped indentations for the train wheels?

After noticing that most edges where not a perfect 90°, I started seeing (and also using) Chamfer in many places:

The next step was to try something with not only straight lines in it, so I started replicating a curved track. It was nice to learn about curved lines defined by their radius, and for example the Offset feature:

After that, I wanted to actually create something new: An intersection! As we didn't have it at the time (but really needed it, according to me and my son :-)), I had no exact model to replicate.

I ended up with 3 different models in total:

Sandbox shovels (3x)

After finishing the train tracks, I wanted to be a bit more creative and actually come up with something myself. As my young kids spent a lot of time in the sand box (and therefore me too), I tried to model some Sandbox shovels:

The first shovel was flat underneath:

But that didn't feel quite right when using it with sand. I noticed that it was much better when there was kind of a "bowel", a scooped shovel:

Much better! It was fun to iterate and try things out, especially to also let others test what they liked best.

I also learned about Fillet and using Extrude to cut off the upper part of the shovel.

Box with magnets

My next project was a small box for a labyrinth card game, and I did a small study on hinges. I am always impressed with the "print-in-place" things you can find on Thingiverse and alike, and I tried coming up with one on my own: Two parts of a box which are connected with a small hinge, not directly connected, but placed in a way that the two parts were being held together.

It turned out actually working:

It wasn't that practical, unfortunately, because there was a lot of wiggle room and the box would close properly, the edges would just overlap and shift around.

I then switched to use 2 strong magnets on the side, so it would "snap" nicely when put together:

This was the final result (I had some first-layer issues with the part with the "L" on it, but decided that it was good enough):

You can find the model here: Box for Labyrinth Card Game

Banana case

The last thing I'd like to share is a Banana protector case - after having several bananas squished when going to the playground with my kids I tried to come up with a design to protect a banana from getting squashed. This is the final result:

It was fun iterating through some ideas, for example:

a pentagonal shape matching the banana (but unreasonable to print)
halving the case laterally (impractical to close because of the round banana shape)
having a small, removable top (not handy to put in banana)

One feature I really liked here was Sweep, which can make a volume from a 2D drawing, following a (rounded!) line:

This is the final STL, which can be moved and zoomed!

You can also check out some other, smaller models I made:

Thanks for reading and happy printing!

xb.sql and xbi.sql - Explain Oracle Execution Plans Better! (Part 3 - Cardinality Misestimates)

Tanel Poder Blog — Mon, 03 Nov 2025 08:00:29 GMT

Here’s part 3 of my xb.sql & xbi.sql article series that I started writing back in 2019 :-)

Part 1 - Show and format execution plans by querying V$SQL_PLAN data directly
Part 2 - Show plan line level “self-values” for A-Time and logical, physical I/Os
Part 3 - Show plan line level cardinality misestimate factors (this article)

The importance of row-count (cardinality) estimates

When I look at complex enough SQLs and optimizer misbehavior, the optimizer cardinality estimates (E-Rows) are the most important optimizer numbers to follow in the execution plan, for understanding the optimizer choices. Of course for the actual execution metrics of the newly optimized plan, we’d look into A-Time, A-Rows, Starts, LIOs and PIOs as I’ve shown in previous posts. In this post, I’ll show how I walk through plans with bad cardinality misestimates and drill down into where those misestimates originate from.

Why Nextcloud feels slow to use

./techtipsy — Mon, 03 Nov 2025 06:00:00 GMT

No amount of tuning the backend service performance helped, and then I learned why. Oh no. Oh no no no no.

The Man from the Future: The Visionary Ideas of John von Neumann

🦉 olshansky 🦁 — Mon, 03 Nov 2025 05:18:52 GMT

tl;dr John von Neumann is a legend, but this book did not do him justice. I highly recommend reading the first two chapters, but there’s no reason to keep going after that.

Review of the Book’s Writing

The book starts off strong, engaging and full of interesting stories about how John von Neumann grew up. It gives a clear picture of how he became the man he was.

But after the first couple of chapters, it turns into a historical account of the Manhattan Project and his role in it. If it had been written from his perspective or explored his internal challenges, it could have been great. Unfortunately, it ends up feeling like a chronological play by play.

TIL: The two phases in LLM inference

🦉 olshansky 🦁 — Mon, 03 Nov 2025 02:48:07 GMT

This is a TIL of a TIL.

Simon Willison wrong of using an NVIDIA DGX Spark with an Apple Mac Studio for faster inference, with all the details here.

He talks about the two phases of inference:

Prefill: Influence Time-To-First-Token (TTFT)
Decode: Influence Tokens Per Second (TPS)

Prefill

Read the prompt
Build a Key-Value Cache for each transformer layer in the model

Bound by compute as it initializes the model’s internal state and does a lot of matrix multiplication.

The Karpathy Principle

🦉 olshansky 🦁 — Mon, 03 Nov 2025 02:39:16 GMT

The Demo-to-Product Gap? The March of nines?

In AI, the last 0.001% takes 99.999% of the time.

We need a name for it, and given how much the Andrej & Dwarkesh interview has been cited, it’s only fair to call it “The Karpathy Principle”.

Here is a 30 second YouTube Clip for reference.

You Need To Become A Full Stack Person

Den Delimarsky — Mon, 03 Nov 2025 02:00:00 GMT

AI tools are commoditizing single-skill roles. The future belongs to people who can think, build, and ship across the entire stack.

Promise based Web Worker Messaging

Muffin Man — Mon, 03 Nov 2025 02:00:00 GMT

If you've ever used Web Workers (or any other event-based communication), you probably noticed that this kind of code can be hard to read and reason about. You also have to implement some kind of identifier for each message to recognize which worker response corresponds to which request.

To simplify that, we can write a small wrapper that lets us use Promises to communicate with Workers. I'll show you an example for Web Workers, but the same pattern can be applied to Service Workers as well.

The resulting API looks like this:

const workerResponse = await sendToWorker(data);

I first used this approach in Pulsar, because I wanted to parse and execute the user's code in a Web Worker, but also wait for the worker to finish before providing data for the next frame.

Implementation #

The idea is fairly simple - before sending a message to the worker, we create a unique id and a promise. We store the promise in a map using the id as the key. Then we send an event to the worker, including both the data and the id, and return the promise to the caller.

When the worker finishes its calculation, it sends back a message that includes the result and the same id. In the main thread, we listen for these messages. When one arrives, we use the id to find the corresponding promise in our map.

Finally, based on the worker's result, we resolve or reject that promise.

It might sound like a lot, but the code is actually quite straightforward:

// Worker initialization
const worker = new Worker("./path-to-your-worker.js");

// Map of promises
const promises = {};

worker.addEventListener("message", (e) => {
  // Listen to worker messages and find the correct promise matching the id
  // Then resolve or reject it depending on the response
  if (e.data.error) {
    promises[e.data.id].reject(e.data.error);
  } else {
    promises[e.data.id].resolve(e.data.data);
  }

  // Remove the resolver reference
  delete promises[e.data.id];
});

// For identifiers it is safe to use a simple integer
// which we increment every time user sends a new message
let id = 0;

// The main method which returns a promise
const sendToWorker = (data) => {
  // Return a promise
  return new Promise((resolve, reject) => {
    // Add resolver to the map
    promises[id] = {
      resolve,
      reject
    };

    // And post user data along with the generated id
    worker.postMessage({
      id,
      data
    });

    // Increase the id
    id++;
  });
};

As mentioned above, the worker code needs to send a message that includes not only the computation result but also the id it received from the main thread:

self.addEventListener("message", (e) => {
  // Do your computations here

  // Send the result back along with id
  self.postMessage({
    id: e.data.id,
    data: `Hello ${e.data.data}`,
  })
});

Why? #

I think that this pattern makes it easier to write more readable code using async/await and straightforward error handling. It also handles id generation, so we don't have to manually track which worker message corresponds to which main thread message.

Hope you find it useful! The code and a basic demo are available on CodePen.

Replacing my old desktop with a high-end Linux PC

Ben E. C. Boyter — Mon, 03 Nov 2025 02:00:00 GMT

I am hoping to get another 5 years out of the machine as it is now.

My previous post about my desktop ended with the above. It has been about 5 years and while I was happy with my old desktop I had started looking into agentic workflows using LLM’s. After burning $50 in an afternoon just debugging some flows against OpenAI I decided I needed a better solution.

A little research and I decided to order and build a new desktop that would solve my immediate problems, as well as last another 10 years. My requirements were fairly simple, as much power as possible in as quiet a form as possible.

An individual can change an organization

Notes on software development — Mon, 03 Nov 2025 02:00:00 GMT

One of the biggest lessons I learned early in my career was from Drew DeVault at Linode, 10 years ago. He was one of the youngest developers in the company (only I was younger, at 20, at the time) but he cared really strongly about thinking through architecture and code decisions when the culture at the time was, and I love those guys, a little haphazard.

Drew had no special position. We all had the same title, "Developer". But he argued so persuasively and so doggedly even when the entire organization seemed against him and somehow he eventually transformed the entire engineering organization.

That's supposed to be impossible! It was entirely new to me. That you don't need to wait behind people with more experience to make the right decision. That you can be part of making the right decision if you can find the logic and the will to do it.

It isn't that simple of course. Politics is politics. But there are plenty of companies with people who will make a good faith effort to do what makes sense but might, without someone's unasked-for effort, do not what makes sense but what is popular because what's popular just kinda seems easiest. And I always like working for these companies, and for the most part have been able to identify them during the interview process.

I learned from Drew to put limited value in seniority. I learned that it's ok to debate. I learned to be prepared and to try to present the facts. I learned to be persistent when I wanted change. I learned that with these skills, it's possible for an individual to redirect the path of an organization.

It took a while longer (and me driving one or two people on my team to quit, to my great regret) to learn when to do these things and when to let things go. Still, this lesson from Drew on what's possible always stands out in my memory. Thank you, Drew.

Drew DeVault taught me a really important lesson early in my career, that it's possible for a person to change the direction of an organization. pic.twitter.com/EGBRdbIjVO
— Phil Eaton (@eatonphil) November 3, 2025

You are doing your team retrospective wrong

Domenico Luciani — Mon, 03 Nov 2025 01:00:00 GMT

A team retrospective is not just another useless meeting, and if you feel so, it means you are doing it wrong, and this article is for you.

Integer overflow checking with C23

Blog on blog.gnoack.org — Sun, 02 Nov 2025 21:48:02 GMT

While I wasn’t looking, C23 has standardized checked integer arithmetic functions, replacing the old “__builtin_mul_overflow()” compiler intrinsics that shipped with GCC and Clang.

#include <stdckdint.h>
bool ckd_add(type1 *result, type2 a, type3 b);
bool ckd_sub(type1 *result, type2 a, type3 b);
bool ckd_mul(type1 *result, type2 a, type3 b);

The operations are performed equivalently to doing them in the mathematically reasonable way (as normal integers in ℤ, not modulo-something), and then truncating them to fit into the *result integer. The function returns true if the resulting value could not be represented in *result’s integer type.

To check for overflow of two integers a and b, define a variable for the calculation result and do:

int result;
if (ckd_mul(&result, a, b)) {
  errx(1, "a * b overflow or wraparound");
}

These semantics remove having to worry of the unintuitive difference between (undefined) integer overflow and (well-defined) unsigned integer wraparound. (The “arithmetic” ways for checking overflow/wraparound differ substantially for signed and unsigned integers, otherwise.)

The feature is available in: GCC 14+, Clang 18+, both released in Q2 2024.

Further references

The Integer section of the SEI C Coding Standard wiki has some excellent guidance for correct overflow and wraparound checks, also for older compilers. Specifically, these sections are:

David Svoboda, who is involved here, is the same person who proposed the extension to the C23 standard.

Jens Gustedt’s Blog has a longer post on the topic as well with more practical examples and a discussion of how to emulate the new interface based on the older macros that GCC and LLVM offered before C23.

The __builtin_mul_overflow() macro and friends were introduced in GCC 5 (2015) and Clang 3.4 (2014).

Interessant3 #165 | 👶Income→Parenthood, 📉EU Debt Swaps, 🤖LLM Moral Trade-offs

Interessant3 — Sun, 02 Nov 2025 21:35:20 GMT

Three Interesting Things for W/C 2025-11-02

Interessant3 #164 | 🧭Incentives, 🗣️Language & Code, 📊UK Productivity

Interessant3 — Sun, 02 Nov 2025 21:30:30 GMT

Three Interesting Things for W/C 2025-10-26

Principles of Economics Made Clear (Part 2)

Photon-Lines Substack — Sun, 02 Nov 2025 17:59:05 GMT

An overview of the key principles of economics presented in a clearly and succinctly.

Quantum Engine

Brian Sunter — Sun, 02 Nov 2025 11:01:40 GMT

A minimal, modular Entity Component System (ECS) game engine in TypeScript. Browser-first, plugin-driven, and tuned for WebGL, Canvas, and modern web APIs.

Sharing Skills: Claude Marketplace to VS Code Workspaces

Tiberriver256 — Sun, 02 Nov 2025 02:00:00 GMT

Part 3 of 3 in the Skills Catalog series (Part 1

Part 2)

You’ve built a skills catalog. Nested domains. Scripts that execute on demand.

Now the final question: How do you share this across your team?

Anthropic distributes skills through their marketplace and Skills API—portable, reusable knowledge packages.

GitHub Copilot doesn’t have a marketplace. But VS Code workspaces achieve the same outcome.

The Problem

Your .github/skills/ directory holds organizational standards, tested scripts, and domain expertise.

But you have multiple repositories—frontend apps, backend services, infrastructure, libraries.

Copy .github/skills/ into each? What happens when you update a script?

That doesn’t scale.

The Solution: Shared Repository + Workspaces

Create one repository holding all organizational skills. Every project references it.

The key insight: VS Code automatically merges .github/copilot-instructions.md files from all workspace folders.

Repository Structure

Create org-skills (or whatever you prefer):

org-skills/
├── README.md
├── .github/
│   ├── copilot-instructions.md
│   └── workflows/
│       └── validate-skills.yml
└── skills/
    ├── azure-devops/
    │   ├── index.md
    │   ├── pipelines.md
    │   ├── repos.md
    │   ├── work-items.md
    │   └── scripts/
    │       ├── get-related-work-items.ps1
    │       └── create-pr.ps1
    ├── aws/
    │   ├── index.md
    │   ├── ec2.md
    │   ├── s3.md
    │   └── scripts/
    ├── docker/
    │   ├── index.md
    │   ├── compose.md
    │   └── templates/
    ├── powershell/
    │   ├── index.md
    │   ├── standards.md
    │   └── modules.md
    └── react/
        ├── index.md
        ├── components.md
        └── patterns.md

This repository becomes your single source of truth.

Version control tracks changes. Teams contribute via PRs. CI validates scripts. Everyone uses the same versions.

VS Code Workspaces

VS Code merges .github/copilot-instructions.md files from all workspace folders. Add a folder, skills become available.

How It Works

Create a .code-workspace file in any project:

my-app.code-workspace:

{
  "folders": [
    {
      "name": "my-app",
      "path": "."
    },
    {
      "name": "org-skills",
      "path": "../org-skills"
    }
  ],
  "settings": {
    "github.copilot.enable": {
      "*": true
    }
  }
}

This workspace includes two folders: the current repository and org-skills.

Open the workspace, and GitHub Copilot reads both .github/copilot-instructions.md files and merges them.

The Shared Repo’s Copilot Instructions

In your org-skills repository, create .github/copilot-instructions.md:

# Organizational Skills

This repository contains organizational knowledge and standards.

## Available Skills

| Skill Name | Description | Path |
|------------|-------------|------|
| Azure DevOps | Work with Azure DevOps repos, pipelines, work items | `skills/azure-devops/index.md` |
| AWS | AWS services and patterns | `skills/aws/index.md` |
| Docker | Container standards and compose patterns | `skills/docker/index.md` |
| PowerShell | PowerShell coding standards | `skills/powershell/index.md` |
| React | React component patterns | `skills/react/index.md` |

Notice paths are relative to org-skills (skills/...), not absolute.

VS Code merges the instructions automatically. Organizational knowledge available, no copying.

Bootstrapping New Projects

When starting a new repository:

Clone the shared skills repo alongside your new project:

cd ~/projects
git clone https://github.com/your-org/my-new-app.git
git clone https://github.com/your-org/org-skills.git

Create a workspace file in my-new-app:

cd my-new-app
cat > my-new-app.code-workspace << 'EOF'
{
  "folders": [
    {
      "name": "my-new-app",
      "path": "."
    },
    {
      "name": "org-skills",
      "path": "../org-skills"
    }
  ]
}
EOF

Open the workspace:

code my-new-app.code-workspace

Done. The project has access to all organizational skills.

Updating Skills

Add or update a skill in org-skills, commit, and push. Every project pulls the latest:

cd ~/projects/org-skills
git pull

All workspaces referencing org-skills see the updates immediately.

What You’ve Built

Over these three parts, you’ve adapted Anthropic’s Skills concept for GitHub Copilot:

Part 1: Auto-discovery → Catalog pattern for navigation

Part 2: Nested structures and scripts → Adapted for the catalog

Part 3: Marketplace distribution → VS Code workspaces for sharing

A system for scaling AI context to hundreds of skills across dozens of repositories.

Your AI doesn’t need to know everything. It just needs to know where to look.

This approach adapts Anthropic Skills for GitHub Copilot. The core concepts—modular knowledge, on-demand loading, shareability—come from Anthropic’s design.

If you build a skills catalog, I’d love to hear about it. Find me on LinkedIn or open an issue on this blog’s GitHub repo.

Sharing Skills: Claude Marketplace to VS Code Workspaces was originally published by Micah Rairdon at Tiberriver256 on November 02, 2025.

Learning from Anthropic: Nested Skills and Scripts

Tiberriver256 — Sun, 02 Nov 2025 02:00:00 GMT

Part 2 of 3 in the Skills Catalog series (Part 1

Part 3)

Part 1 covered the catalog pattern. Now: how do you organize knowledge that scales to hundreds of skills?

Anthropic’s skills repository shows patterns for complex domains:

Nested structures for complex domains
Scripts as executable knowledge
Supporting resources (templates, configs)

Anthropic’s Nested Skills

The mcp-builder skill:

mcp-builder/
├── SKILL.md                    # Main skill description
├── guides/
│   ├── getting-started.md
│   ├── server-patterns.md
│   └── testing.md
├── templates/
│   ├── basic-server.py
│   └── typescript-server/
└── scripts/
    ├── create-server.sh
    └── test-server.sh

Pattern:

SKILL.md: Overview with description for discovery
Guides: Detailed sub-topics
Templates: Starting code
Scripts: Executable automation

Keeps SKILL.md lean—points to guides. Claude loads guides selectively.

Adapting for the Catalog

Top-Level Catalog

.github/copilot-instructions.md stays high-level:

## Available Skills

| Skill Name | Description | Path |
|------------|-------------|------|
| Azure DevOps | Work with Azure DevOps repos, pipelines, work items | `.github/skills/azure-devops/index.md` |
| React | React component patterns and standards | `.github/skills/react/index.md` |

Each skill points to an index.md (like Anthropic’s SKILL.md).

Domain Index (Sub-Catalog)

.github/skills/azure-devops/index.md becomes a second-level catalog:

# Azure DevOps Skill

## Sub-Skills

| Sub-Skill | Description | Path |
|-----------|-------------|------|
| Repositories | Branch policies, PRs, code reviews | `./repos.md` |
| Pipelines | YAML pipelines, triggers, monorepo support | `./pipelines.md` |
| Work Items | Queries, custom fields, automation | `./work-items.md` |

## Quick References

- Organization: `https://dev.azure.com/yourorg`
- Project: `YourProject`

## Scripts

- `scripts/get-related-work-items.ps1` - Get work items for pipeline run
- `scripts/create-pr.ps1` - Create PR with template

Two-level indexing:

Main catalog → Azure DevOps skill exists
Azure DevOps index → Pipelines sub-skill for pipeline questions

Sub-Skill Files

.github/skills/azure-devops/pipelines.md contains focused knowledge:

# Azure DevOps Pipelines

## YAML Standards

All pipelines must:
- Use YAML (no classic pipelines)
- Include `trigger.paths` for monorepos
- Use named stages for multi-stage deployments

## Monorepo Trigger Pattern

```yaml
trigger:
  branches:
    include:
      - main
  paths:
    include:
      - services/api/*
      - shared/common/*
```

## Getting Related Work Items

Azure DevOps's built-in feature doesn't support monorepos. Use:

```bash
pwsh .github/skills/azure-devops/scripts/get-related-work-items.ps1
```

See `./scripts/get-related-work-items.ps1` for details.

Directory Structure

Here’s what it looks like (modeled on Anthropic’s pattern):

.github/skills/azure-devops/
├── index.md                    # Sub-skills catalog (like Anthropic's SKILL.md)
├── repos.md                    # Repository sub-skill
├── pipelines.md                # Pipelines sub-skill
├── work-items.md               # Work items sub-skill
├── scripts/                    # Executable automation (like Anthropic)
│   ├── get-related-work-items.ps1
│   ├── create-pr.ps1
│   └── query-work-items.ps1
└── templates/                  # Starting points (like Anthropic)
    ├── pr-template.md
    └── pipeline-template.yml

Each .md file is 5-15KB. Same pattern Anthropic uses, adapted for explicit catalog navigation.

Scripts: Learning from Anthropic

Both Anthropic Skills and the catalog pattern support scripts as executable knowledge.

Anthropic’s Approach

Look at the mcp-builder skill. It includes:

scripts/create-server.sh - Bootstrap a new MCP server
scripts/test-server.sh - Validate server implementation

These aren’t documentation about how to create a server—they’re executable scripts that do it. Claude can invoke them directly.

The philosophy: Don’t just describe processes. Provide tested, working automation.

Catalog Adaptation

Reference scripts in skill files:

In .github/skills/azure-devops/pipelines.md:

## Getting Related Work Items

Azure DevOps's built-in feature doesn't support monorepos. Use:

```bash
pwsh .github/skills/azure-devops/scripts/get-related-work-items.ps1 -BuildId $BUILD_BUILDID
```

Script conventions:

Self-contained: Include dependencies
Documented: Header comments
Tested: Production-ready
Referenced: Skill files tell AI when to use them

Example .github/skills/azure-devops/scripts/get-related-work-items.ps1:

<#
.SYNOPSIS
    Retrieves commits and work items for a build pipeline with monorepo support.

.DESCRIPTION
    Azure DevOps's built-in "Related Work Items" feature doesn't filter by
    pipeline trigger paths in monorepos. This script does.

.PARAMETER BuildId
    The ID of the build. Defaults to $ENV:BUILD_BUILDID in Azure Pipelines.

.PARAMETER CollectionUri
    Azure DevOps organization URI. Defaults to $ENV:SYSTEM_COLLECTIONURI.

.EXAMPLE
    ./get-related-work-items.ps1 -BuildId 12345

.NOTES
    Requires the powershell-yaml module for parsing YAML pipeline files.
#>

[CmdletBinding()]
param (
    [Parameter()]
    [int]$BuildId = $ENV:BUILD_BUILDID,

    [Parameter()]
    [Uri]$CollectionUri = $ENV:SYSTEM_COLLECTIONURI,

    [Parameter()]
    [Guid]$ProjectId = $ENV:SYSTEM_TEAMPROJECTID,

    [Parameter()]
    $AuthorizationHeader = "Bearer $ENV:SYSTEM_ACCESSTOKEN"
)

# (Full implementation omitted for brevity)

Why Scripts Matter

Traditional: AI generates code. Sometimes buggy.

Skills approach: AI uses tested scripts. Deterministic results.

Now, when the AI encounters a monorepo pipeline question, it:

Loads the pipelines sub-skill
Sees the script reference
Suggests running the script or shows how to invoke it

You get deterministic, tested behavior instead of AI-generated code that might have bugs.

Why Scripts Beat Always-On Tools

MCP (Model Context Protocol) servers are powerful but costly—they’re always in context.

20 MCP servers × 10-50 tools = 200-1000 tool descriptions before you’ve asked anything.

Scripts are opt-in. Load only when:

AI reads the skill file
Skill is relevant

Azure questions? Azure scripts. React questions? React scripts.

Invoking MCP via Scripts

But what if a vendor ships an MCP server without a CLI? You still want opt-in behavior.

Solution: Wrap the MCP server in a lightweight CLI client, then call it from scripts.

Example: A hypothetical Jira MCP server.

Create .github/skills/jira/scripts/mcp-client.sh:

#!/bin/bash
# Lightweight MCP client that invokes Jira MCP server tools

TOOL_NAME=$1
shift
ARGS="$@"

# Connect to MCP server and invoke tool
npx @your-org/mcp-client \
  --server jira-mcp-server \
  --tool "$TOOL_NAME" \
  --args "$ARGS"

Now your Jira skill can reference ./scripts/create-issue.sh:

#!/bin/bash
# Create a Jira issue

./mcp-client.sh create-issue \
  --project "PROJ" \
  --summary "$1" \
  --description "$2"

The MCP server’s capabilities are available, but only when the Jira skill loads and the AI decides to run the script.

You control when capabilities enter the context.

Composing Skills: The Fractal Pattern

Nested skills can go deeper. Azure DevOps → Pipelines → Monorepo Triggers → Path Filtering.

Just add another layer:

.github/skills/azure-devops/pipelines/
├── index.md                    # Pipelines overview + sub-catalog
├── triggers.md                 # Trigger patterns
├── variables.md                # Variables and parameters
├── templates.md                # Template usage
└── monorepo/
    ├── index.md                # Monorepo-specific guidance
    ├── path-filtering.md       # Path filter patterns
    └── scripts/
        └── get-related-work-items.ps1

Each level has a catalog. AI navigates general → specific.

Practical limit: 3-4 levels.

Section Conventions

Within each skill file, use consistent sections:

# [Skill Name]

## Overview
What this skill covers

## Standards
Your organizational rules

## Common Patterns
Frequently used code/configs

## Scripts
Executable automation

## Templates
Starting points

## Troubleshooting
Known issues and fixes

## References
External docs, links

AI learns this structure, finding information faster.

Building a Nested Skill

Create an Azure DevOps skill:

Step 1: Create the directory structure

mkdir -p .github/skills/azure-devops/{scripts,templates}

Step 2: Create the index (.github/skills/azure-devops/index.md)

# Azure DevOps Skill

## Sub-Skills

| Sub-Skill | Description | Path |
|-----------|-------------|------|
| Pipelines | YAML pipelines, triggers, monorepo support | `./pipelines.md` |

## Scripts

- `scripts/get-related-work-items.ps1` - Get work items for a pipeline run

Create pipelines.md with standards, examples, script references. Add a tested PowerShell script. Reference in main catalog.

Key Takeaways

Keep main files lean—nest details
Provide scripts—executable knowledge
Use consistent structures
Include templates and examples

Scaling to 100+ Skills

With this structure:

10 domain skills (Azure DevOps, AWS, Docker, React, etc.)
5-10 sub-skills each (50-100 sub-skills total)
2-5 scripts per sub-skill (100-500 scripts total)

Total catalog overhead: ~10KB (main) + ~50KB (indexes) = 60KB

Total knowledge base: 5-50MB of detailed docs and scripts

Megabytes of knowledge through a 60KB index.

Part 3: Shared skills repository + VS Code workspaces for portable organizational knowledge.

Start nesting:

Pick one skill
Break into 2-3 sub-skills
Move one task into a script

Credit: This series adapts patterns from Anthropic Skills. The nested structure and script conventions mirror their official examples.

Learning from Anthropic: Nested Skills and Scripts was originally published by Micah Rairdon at Tiberriver256 on November 02, 2025.

Bringing Anthropic Skills to GitHub Copilot

Tiberriver256 — Sun, 02 Nov 2025 02:00:00 GMT

Part 1 of 3 in the Skills Catalog series (Part 2

Part 3)

Anthropic just announced Skills—modular, discoverable knowledge for Claude. Each skill is a SKILL.md file with metadata. Claude discovers them through the description field. No central catalog, no manual wiring.

Can we bring this to GitHub Copilot? Yes—with one key adaptation: a catalog table that replaces Claude’s auto-discovery.

What Are Anthropic Skills?

From their Skills announcement and official repository:

The Structure

Each skill is a folder containing a SKILL.md file with YAML frontmatter:

---
description: "Work with Azure DevOps pipelines, triggers, and YAML configurations"
---

# Azure DevOps Pipelines

Your skill content in markdown...

That’s it. The description field is how Claude discovers what the skill does. The rest is just markdown.

How Discovery Works

When you work with Claude (in Claude.ai, Claude Code, or via API), it scans available skills and uses the description field to decide which ones are relevant. No central catalog. No manual selection. Just self-describing knowledge packages.

Example workflow:

You ask: “How do I set up a monorepo trigger in Azure DevOps?”
Claude scans skill descriptions
Finds “Work with Azure DevOps pipelines, triggers…” matches
Loads that SKILL.md file
Uses the knowledge to answer your question

The Core Concept

The philosophy:

Modular: One skill = one domain
Discoverable: Metadata makes skills findable
On-demand: Load only when relevant
Self-describing: No central registry

Why This Concept Transfers

The underlying problem Anthropic Skills solve is universal: how do you give AI access to vast knowledge without overwhelming the context window?

Their answer: hint, then dive.

Skills hint through description fields
Claude dives into relevant skills when needed
Irrelevant knowledge stays out of context

This pattern works regardless of the AI platform. The mechanics might differ, but the concept holds.

Bringing It to GitHub Copilot

The challenge: GitHub Copilot doesn’t auto-discover skills like Claude does.

Copilot reads files you explicitly include (.github/copilot-instructions.md), but doesn’t scan skill folders or match descriptions to questions.

The adaptation: Replace auto-discovery with a catalog table.

The Catalog Pattern

Create a lightweight index—a table listing skills with descriptions and paths:

| Skill Name | Description | Path |
|------------|-------------|------|
| Azure DevOps Pipelines | Work with Azure DevOps YAML pipelines, triggers, variables | `.github/skills/azure-devops-pipelines.md` |
| PowerShell Standards | Coding standards and common patterns for PowerShell | `.github/skills/powershell-standards.md` |
| React Component Patterns | Approved component patterns and examples | `.github/skills/react-patterns.md` |

This table lives in .github/copilot-instructions.md (always loaded).

How it works:

You ask: “Help me set up a monorepo trigger for Azure DevOps”
Copilot scans the catalog table (which is always in context)
Matches “Azure DevOps Pipelines” description to your question
Reads .github/skills/azure-devops-pipelines.md
Uses that knowledge to answer

Same outcome—different discovery mechanism.

Why the Catalog Works

The catalog is tiny: 100 skills ≈ 5,000-10,000 tokens.

Each skill file: 5,000-50,000 tokens. Loading all 100 upfront: 500,000-5,000,000 tokens.

The catalog scales to hundreds of skills while keeping base context lean.

Copilot loads only what it needs. Azure pipelines? Azure skill. React? React patterns.

Benefits:

Precision: Only relevant knowledge loads
Scale: Hundreds of skills supported
Performance: Lean context window

Implementation

Step 1: Create .github/copilot-instructions.md:

# Skills Catalog

This repository adapts Anthropic's Skills concept for GitHub Copilot.

## Available Skills

| Skill Name | Description | Path |
|------------|-------------|------|
| Azure DevOps Pipelines | Work with Azure DevOps YAML pipelines, triggers, variables | `.github/skills/azure-devops-pipelines.md` |
| PowerShell Standards | Coding standards and common patterns for PowerShell | `.github/skills/powershell-standards.md` |

## How to Use Skills

When you encounter a task related to a skill:
1. Read the skill file at the listed path
2. Follow any guidance, standards, or templates provided
3. Use any scripts referenced in the skill file

Step 2: Create a skill file at .github/skills/azure-devops-pipelines.md:

# Azure DevOps Pipelines Skill

## Overview
Standards and patterns for Azure DevOps YAML pipelines.

## Monorepo Trigger Pattern

For monorepos, filter triggers by path:

```yaml
trigger:
  branches:
    include:
      - main
  paths:
    include:
      - services/api/*
      - shared/common/*

Standards

Use YAML (no classic pipelines)
Include trigger.paths for monorepos
Use named stages for multi-stage deployments ```

Done.

What Goes in a Skill File?

Like Anthropic’s SKILL.md format, keep each skill focused on one domain:

Overview: What this skill covers
Key concepts: Core knowledge
Standards: Your organizational conventions
Examples: Code samples, templates
Scripts: Paths to executable automation (more on this in Part 2)
References: Links to external docs

If a skill grows beyond 10-20KB, break it into sub-skills (covered in Part 2).

GitHub Copilot Enhancements

Path-specific instructions in .github/instructions/:

---
applyTo: "src/api/**"
---

When working with files in src/api/:
- All API endpoints must include OpenAPI documentation
- See `.github/skills/api-patterns.md` for approved patterns

This builds layers:

Repository-wide: .github/copilot-instructions.md with the skills catalog
Path-specific: .github/instructions/*.instructions.md for targeted guidance
Skill files: .github/skills/*.md for detailed domain knowledge

Why This Works

Anthropic Skills separate discovery (description field) from content (markdown).

The catalog does the same:

Discovery: Catalog table (always in context)
Content: Skill files (loaded on demand)

Same benefits:

Modular knowledge packages
On-demand loading
Scales to hundreds of skills

Real-World Impact

This pattern enables:

50+ organizational skills
80%+ reduction in context bloat
Team knowledge discovery
Portable knowledge bases

Next Steps

Part 2: How Anthropic structures complex skills (like mcp-builder) and adapting nested patterns.

Part 3: Distributing skills across your organization using VS Code workspaces.

Start simple:

Create .github/copilot-instructions.md with a skills catalog
Add 2-3 skills
Create one skill file with your conventions

Credit: This series adapts concepts from Anthropic Skills. The catalog pattern is the GitHub Copilot implementation of their discovery mechanism.

Bringing Anthropic Skills to GitHub Copilot was originally published by Micah Rairdon at Tiberriver256 on November 02, 2025.

Corporate kangaroo court - the GitHub edition

Charles Féval — Sun, 02 Nov 2025 02:00:00 GMT

If you value your stuff, you should own your stuff

Silent Hill f Review (PS5, 2025)

tohya.net — Sat, 01 Nov 2025 20:14:30 GMT

Minor spoilers this time. But I imagine everyone who was interested in playing the game blind already did so.

Silent Hill f Review (PS5, 2025)

tohya.net — Sat, 01 Nov 2025 20:14:30 GMT

Minor spoilers this time. But I imagine everyone who was interested in playing the game blind already did so.

Snow Crash et le style de vie "thermodynamiquement intense" (Neil Stephenson)

Alexandre Storelli — Sat, 01 Nov 2025 19:50:35 GMT

Tous ces Blancs massifs avec leurs flingues ! Regroupez-en suffisamment, à la recherche d’une Amérique où ils ont toujours cru qu’ils grandiraient un jour, et ils s’agglutinent comme du riz trop cuit, formant des plaques collantes et denses. Avec leurs

We had a breakthrough in AI with transformers. ...

Kevin B. Ridgway's Blog — Sat, 01 Nov 2025 16:16:08 GMT

We had a breakthrough in AI with transformers.

Where’s our breakthrough in AI with alignment?

Why your retrospectives don't work and how to fix them

Lucas F. Costa - Blog — Sat, 01 Nov 2025 14:00:00 GMT

Every team must believe in improvement, even when it no longer happens. That’s what retrospectives are for. Most teams also use retrospectives for documenting problems that nobody has time to fix. T...

Engineering a Rust optimization quiz

fasterthanli.me — Sat, 01 Nov 2025 13:08:00 GMT

There are several Rust quizzes online, including one that’s literally called the “Unfair Rust Quiz” at https://this.quiz.is.fckn.gay/, but when I was given the opportunity to record an episode of the Self-Directed Research podcast live on the main stage of EuroRust 2025, I thought I’d come up with something special.

The unfair rust quiz really deserves its name. It is best passed with a knowledgeable friend by your side.

2025.10.DisappearingMoment

Disappearing Moment — Sat, 01 Nov 2025 04:47:55 GMT

In my experience, accountability has four requirements:

Truth
Timeliness
Legibility
Storytelling

No lies or errors. Reveal what you know as soon as it’s pertinent. Put it where people who might think it’s useful will see it or can find it with little effort. Explain it in the most inviting and succinct way possible.

In this year’s March and April newsletters, I wrote about investments that I made. It’s time to see how I did.

Let’s start with what investing is and why we do it. By which I mean, investing in stocks.

When you buy a share of stock, you become one of the owners of the company. If you buy a share of the Coca-Cola Company for $70, you own one of its 4.3 billion shares.

You get to vote for its board of directors.
When Coca-Cola sends its annual dividend checks, you will get $2.04.
If someone offers to buy the company for $100 per share, you can vote on the offer.
If this theoretical sale happens, you get $100 for your share.

Why does a share of Coca-Cola cost $70? That’s the equilibrium between where people want to buy it and sell it. In the short run, the stock market Is a voting machine. In the long run, the stock market Is a weighing machine.

“Voting” means that sometimes people get excited about stocks (e.g. GameStop). It means that stocks, and entire markets, are prone to bubbles and crashes.

“Weighing” means that, over time, companies’ prices and their value tend to correspond. Over time, the price of Coca-Cola should match its value.

What do I mean by value? In a word, "earnings". That's the money that Coca-Cola has left after it pays its expenses.

The company sells a lot of Coke, which makes it a lot of money: $47.7 billion last year. Its expenses included employees, taxes, interest on debt, ingredients, packaging, and advertising. What it has left is earnings. Last year, per share, it had $3.02 in earnings. A lot of that went to dividends. The rest went back into the business.

When you think about a company’s value, you think about its earnings:

What it will earn next year, the year after, and so on.
What it will pay in dividends.
What a buyer might pay for it (also a function of earnings).
What Coca-Cola might do to increase its earnings (AI! Protein!).
What might cause Coca-Cola to have lower earnings (Tariffs! Panics!).

What if most investors think Coca-Cola’s earnings will grow faster than "the market"? Then there will be more buyers than sellers. If that happens, the price goes up (e.g. Nvidia) until there is a new equilibrium. The opposite happens if a lot of people think Coca-Cola’s earnings will trail the market average.

Making and acting on these projections is what stock analysts do for a living. Stock analysts tend to be smart and obsessive. If you are not good at projecting companies’ earnings, it might be a bad idea to buy stocks. When you buy individual stocks, you are trading with professional stock analysts.

If you are bad at stock analysis, you should buy mutual funds or exchange-traded funds (ETFs). The professional investors who operate these funds tell you how they’re going to invest. If they invest in stocks, they tell you what theme or strategy they will follow. Their goal is to buy stocks whose prices increase faster than the stocks they don’t buy.

People who are bad at choosing stocks aren't much better at choosing fund managers. This, too, is a full-time job for smart, obsessive people. For instance, professionals who manage endowments get paid to pick good fund managers.

The alternative is to pick all the professional investors. Stock trades involve a buyer and seller, so professional investors as a whole tend to do as well as the market. Many funds let you buy the entire market or a part of the market.

The S&P 500 is a collection of big companies that mirrors the entire U.S. market. The Russell 3000 is the same idea, only with more companies. Or you can buy a collection that’s meant to do the same thing for the largest non-U.S. companies. There are a lot of collections.

These collections (e.g. S&P 500, Russell 3000) are "indexes". Buying the stocks in an index is dead simple for fund companies (e.g. Vanguard, Fidelity, BlackRock). So it costs you less to invest in index funds than in funds where a person or team make each decision to buy or sell. These "managed" funds cost more because you’re paying for expertise.

I discussed two different managed funds earlier this year, one in March, the other in April. Small teams of well paid specialists make decisions about each stock in these funds:

Joel Greenblatt, Robert Goldstein, Michael Venuto, and Charles Ragauss manage Gotham Short Strategies ETF (SHRT)
Cliff Asness, Michele Aghassi, Andrea Frazzini, John Huss, and Laura Serban manage AQR Long-Short Equity Fund (QLENX)

Greenblatt and Asness write a lot. I understand what they and their teams will do and why, so Beth and I are keeping our money in these funds.

Were these good decisions?

In the March 31 newsletter, I wrote about Gotham Short Strategies ETF. If you decided to invest in that ETF the next day, you could have bought it when the market opened on April 1 for $8.16 per share. It’s now worth $7.28, a -10.78% return on investment, and a -17.76% annualized return.

By comparison, the second largest ETF, iShares Core S&P 500 ETF (IVV), an index fund, opened at $560.02 on April 1. It’s now worth $685.23, a 22.36% return on investment, and a 41.31% annualized return.

If you are into ESG investing, the largest ESG ETF is iShares ESG Aware MSCI USA ETF (ESGU). This index fund opened at $121.45 on April 1. It’s now worth $149.62, a 22.19% return on investment, and a 42.97% annualized return.

I was off by about 60% on an annualized basis. “Annualized” is the way most of us think about these kinds of things. When you make 4% interest in your savings account, that’s annualized. As is the 7% interest on your mortgage or the 20% interest on your credit card.

Off by 60% is awful. How about the other fund?

In the April 30 newsletter, I wrote about AQR Long-Short Equity Fund. If you decided to invest in that fund the next day, you could have bought it when the market opened on May 1 for $17.20 per share. It’s now worth $19.58, a 13.84% return on investment, and a 29.50% annualized return.

The iShares Core S&P 500 ETF (IVV) opened at $563.02 on May 1. It’s worth $685.23, a 21.71% return on investment, and a 47.96% annualized return. The iShares ESG Aware MSCI USA ETF (ESGU) opened at $122.30 on May 1. It’s worth $149.62, a 22.34% return on investment, and a 49.50% annualized return.

I was off by about 20% annualized. Oops?

In April, I included a Howard Marks quote: “…being too far ahead of your time is indistinguishable from being wrong.”

Ahead of my time or wrong. You decide. Anyway, I’m stubborn. Plus, who doesn’t love a bit of cognitive dissonance?

Here’s what I see:

Signs of a Bubble: Schiller PE Ratio. When stock investors “vote” to spend a lot for companies’ earnings, that often precedes a crash. Investors are paying over $40 for each $1 of earnings. That’s the second highest amount in history. (Counterpoint by Jonathan Ping, one of my favorite personal finance writers.)
Signs of a Bubble: Gold. Investors buy gold when they’re worried about inflation and crashes. Gold is at an all-time high.
Signs of a Bubble: Bitcoin, Bitcoin, Bitcoin. Cryptocurrency is a bet that others are stupider and greedier than you. (They aren’t.) At least tulips are lovely.
Investing requires facts.

In March and April, I ended my introduction with the same three paragraphs, that I will repeat again:

None of this is investing advice. Never make an investment based on what you read in this newsletter. Or any newsletter. I know you and you know better.

I have shared this information because I want to be transparent. Writing helps me think through the implications of my beliefs. Maybe what I’ve written will help you.

If you feel confident in U.S. markets and America, this could be an opportunity for you to adjust your allocations. If you don’t, you might think about what that means for your finances.

Note: I got my data from Yahoo Finance. I ran my numbers through the Return on Investment (ROI) Calculator

Welcome to October 2025’s Disappearing Moment, an inventory of my experiences. I hope you enjoy it.

Podcast

Our New York Table (I Liked It): When I am stressed, I like to eat food, watch food, and listen to food.

Nerdy Software

Writing Month is here for your NaNoWriMo (RIP).

Free Font

Erewhon comes from Utopia via Heuristica, which means nothing to any of us. It’s a nifty font from the crazy world of Michael Sharpe.

Bougie Products

Body Glide. If you know, you wish you didn’t.

Personal Finance and Investing

Cancel the subscriptions you don’t need. If you can afford it, sponsor independent writers, publishers, or podcasts. Fuck Substack.

Reading

Mikl Em, “Long Now Years: Five-digit Dates and Y10K-compliance at Home” (I Liked It): Nerdy and optimistic, like me.
Brian Grubb, “Louvre Heist Top Five” (I Loved It): This happened on October 19. I learned about it on October 27. Just in time.
Karen Hao, Empire of AI (2025) (I Loved It): Comprehensive, damning, and a page turner. Fuck OpenAI.
Wendy Herlich, “The Jury Man” (I Loved It): My kind of short story.
Annalee Newitz, Automatic Noodle (2025) (I Loved It): Not subtle. Neither were my tears.
David Rosenthal,“The Gaslit Asset Class” (A Personal Favorite): It’s libraries all the way down.
Wikipedia, “Thank you to Fuzheado and Pharos” (I Loved It): Chilling and lovely.
Sarah Wynn-Williams, Careless People (2025) (I Loved It): Say it with me: Fuck Zuckerberg. If you use Facebook, Instagram, WhatsApp, I hope there’s a god to help you and bless your heart.

Literary Journal

Jet Fuel Review has beautiful design, discerning editors, and is free to access. Also: thoughtful (form) rejection letters. Now I'm more determined.

Survey

To see the survey and respond to it, you have to subscribe via email and answer it through an email interface.

Last month’s question: “How many short stories do you read each year?”

Not only do y’all not read short stories, y’all don’t answer surveys about them. Only three answers this month, all “1–5.”

No shame from me. That’s how I would have answered before September. If you follow the links in my Reading section, you’ll start reading one short story each month.

Bobbing for Roberts

Bobby Altman
Robert Brown
Bobby Carlyle
Bob Downey, Jr.
Bob Englund
Bob Frost
Sir Robert Geldof
Robert Hull
Injustice Roberts
Bob Johnson
Bob Kennedy, Jr.
Bobby Lowe
Robert Marley
Robert Newhart
Bobby Oppenheimer
Bob Plant
Bobby Quine
Robert Ross
Robert Seger
Bob Tables
Bobby Uecker
Robert Villa
Bob Wilson
Robert Xavier
Robert’s Your Uncle
Bobby Zimmerman

See also: Backlund, Barker, Clarke, Costas, Cousy, Darin, De Niro, Dole, Duvall, Feller, Fischer, Fripp, Gibson, Goulet, Griese, Gronkowski, Guillaume, Hope, Hoskins, Jindal, McFerrin, Mitchum, Mould, Mugabe, Orr, Parish, Pattison, Redford, Saget, Sands, Schumann, Seale, Smith, Stevenson, Warren, Zemeckis

Thanks to Jake for her help with this month’s list. And thank you for spending a few moments with me.

I appreciate you and look forward to corresponding again next month.

Brett

Want to discuss this newsletter or anything else with other Disappearing Moment readers? Please sign up for Perpetual August. It might be fun.

The Rise of The Machines

Photon-Lines Substack — Fri, 31 Oct 2025 17:09:09 GMT

Is this story written by my, or an LLM? Try to take a guess...

Agentic Coding Workshop on Vanishing Gradients

Eleanor on Everything — Fri, 31 Oct 2025 10:11:34 GMT

I had a lot of fun doing this live agentic coding workshop with Isaac and Hugo.

The Florian Schneider Collection

Nicola Iarocci — Fri, 31 Oct 2025 10:07:52 GMT

It is impossible to tell the story of electronic music without examining the pioneering beats, grooves, and performance aesthetics of Dusseldorf’s Kraftwerk and its founding member, Florian Schneider. Formed in 1970, the band brought an experimental approach to pop music, resulting in some of the most innovative and commercially successful electronic albums of the mid-1970s into the 1980s: Autobahn, Trans-Europe Express, The Man-Machine, and Computer World.

The Florian Schneider Collection is the first auction to feature a comprehensive collection of items from Florian’s personal life and career, providing a tantalizing glimpse at his and Kraftwerk’s often-enigmatic musical processes. The sale features over 450 lots of stage- and studio-played instruments and gear, clothing, artwork and furniture from Florian’s home and studios (as well as from Kraftwerk’s Kling Klang Studio), bicycles, Kraftwerk memorabilia, and Florian’s extensive collection of historic woodwind and brass instruments (flutes, clarinets, oboes, saxophones, horns, tubas, and one-of-a-kind oddities).

“Slop Coding” and Responsible Testers

Satisfice, Inc. — Fri, 31 Oct 2025 03:46:55 GMT

When I first heard the term “vibe coding”– a day that shall live in euphemy– I immediately disliked its cutesiness. I’ve found that in my own work I am doing “vibe coding” to create test tools that I need for various projects. But I have a problem: how do I tell other people what I’ve […]

Ghosts in the Compilation

Predrag Gruevski's blog and personal site. — Fri, 31 Oct 2025 02:00:00 GMT

Recently, a cargo-semver-checks user reached out with a conundrum: cargo-semver-checks reported being unable to build their crate, but when they ran cargo check themselves, it always completed successfully. Something cursed was going on! The fix is part of the upcoming cargo-semver-checks v0.45 release—what better day than Halloween to talk about this ghost story!

The Orchestrator Pattern: Orchestrating AI Agents Like a Mission Control Engineer

Zachary Proser — Fri, 31 Oct 2025 02:00:00 GMT

A single developer can now direct multiple agentic coding agents across maintenance tasks while simultaneously building features in Cursor. Here's how the Orchestrator Pattern changes software development.

WisprFlow Became the Highest-Leverage Upgrade to My Dev Workflow

Zachary Proser — Fri, 31 Oct 2025 02:00:00 GMT

How adopting WisprFlow transformed my agentic, voice-driven development workflow and unlocked new levels of velocity.

Oops, my UUIDs collided!

Built on Shards of Silicon: Robert Alexander's Tech Blog — Fri, 31 Oct 2025 02:00:00 GMT

Why UUID collisions happen in practice

Avoiding Homebrew Upgrades That Require Sudo on macOS

Krystian Safjan's Blog — Fri, 31 Oct 2025 01:00:00 GMT

Learn how to manage Homebrew upgrades on macOS to avoid sudo prompts, by differentiating between formulae and casks and using specific commands like --formula, --cask, and pinning problematic packages.

Advice For My Nephew

Tynan.com — Thu, 30 Oct 2025 21:20:08 GMT

My nephew is getting old enough that his little personality is starting to come out and I can imagine him going through the different phases of life. He’s still too young to need or to listen to any of my advice, but that doesn’t prevent me from wanting to give it to him. I’ve decided […]

Cutting through slop with minimal time and attention

Jelle Smet — Thu, 30 Oct 2025 21:00:00 GMT

We are living in the attention economy more than ever. While algorithms initially used human-made content to captivate our attention, they are now bombarding us with AI generated slop. What tools can we apply to cut through this and extract the essence saving precious time and attention.

AI generated slop …

Getting HTTP/3 on Cloudflare with Firefox

brycewray.com — Thu, 30 Oct 2025 19:28:00 GMT

There are two paths to the goal, although I can use only one.

On Foraging Mushrooms at Cheesman Park

Josh Thompson — Thu, 30 Oct 2025 15:00:00 GMT

Introduction

I live quite close to this park in Denver, Cheesman Park. Last year, I wrote something about accessing the Botanic Gardens from Cheesman.

A few months later I updated it, noting that I’d found mushrooms in the park and began feeding them to the fish.

I also regularly am in the park doing these barefoot hill sprint things

The koi fish obviously love the mushrooms, I’ve fed them to the fish dozens of times, now.

< todo: add a photo or video of the koi busily eating mushrooms >

As I spent more attention on the mushrooms, I got some books about mushrooms identification, from the botanic gardens library, so I could positivity identify whatever kind of mushroom this was with more confidence than the seek app + me looking at photos of things online.

Agaricus Bisporus

turns out it’s not too difficult to classify mushrooms. It’s a bit of a flow chart one works through. I learned to positively identify these mushrooms, as well as the two kinds of mushrooms responsible for 100% of fatal mushroom ingestions.

It helps to be able to easily observe the mushroom across all stages of development. I made my first spore prints.

This mushroom variety is known as ‘the common mushroom’, agaricus bisporis (wikipedia). It’s the most commonly consumed mushrooms in the world also the same as what you could buy in the grocery store.

The common mushroom! And so abundant in the park. I love common things. It’s the most commonly sold mushroom in grocery stores. I often note the mushrooms for sale, when I pass by them in a grocery store. I’v not bought a mushroom in the better part of a year.

Here’s some of what the page on wikipedia says:a

It is cultivated in more than 70 countries and is one of the most commonly and widely consumed mushrooms in the world. It has two color states while immature – white and brown – both of which have various names, with additional names for the mature state, such as chestnut, portobello, portabellini, button, cremini, and champignon de Paris.

🍄 from the park vs the grocery store

Since that moment over a year ago, I’ve fully replaced my mushroom purchasing from grocery stores with mushrooms chosen from Cheesman park, and it’s been a persistent source of interestingness, and a quality-of-life improvement across many dimensions.

I pass by the park far more frequently than I go to a grocery store, and I pass through the park on my way to other places, on my scooter, all the time, and I can, with a glance from my scooter as I ride by, check different spots I’ve seen mushrooms growing, or a quick walk about. There’s almost always many, many more findable mushrooms than I could ever pick, even on the days that I’ve picked 35 pounds of mushrooms.

Getting mushrooms from the park sort of reminds me of the experience of having a corner store that sells produce, right around the corner from wherever I’m living, and I can dash inside and get vegetables for dinner that night or the next day, any time of day and night, as I’m walking home.

This experience (the ‘corner grocery store’) is common in so many cities around the world, but is ‘banned’ in america because supremacists got their way and still do. ¹

I have been willing but unhappy to be giving money to capitalism, especially the kind of capitalism of local chain grocery stores. A corner, neighborhood grocer, I’d prefer to give my money too, but that’s not even a viable option, because of “zoning”.

with this park mushroom encounter, however, I now have something with the convenience of a veggie stand a half block away, yet it doesn’t even allow for money to be transacted, and it’s always open. As long as it’s not too wintery outside, the park has had mushrooms in it 100% of the times I’ve been there. The park is watered regularly, and that helps there be lots of mushrooms continuously.

No one is forced to run a checkout machine, no electronic devices are used to collect money. There is no concept of ‘price per pound’. I usually walk through the grass barefoot. There’s no florescent lighting. I can collect in large-enough quantities that if I wanted to go weeks between a visit to the park, I could. The largest amount I once collected was just as much as I could fit in my backpack and the two grocery bags I had with me, and it was 35 lbs of mushrooms. It was still only a small fraction of the ripe, edible mushrooms available in the park at that moment.

I’ve certainly become much more attentive to how the grass and dirt feels under my toes, the presence of moisture, the temperatures that I notice, when walking around the park, too. Less capitalism and more nature and walking barefoot in wet grass? Yes please. I am still using it for my barefoot hill sprints

Where in the park to find them

The mushrooms grow in very reasonable patterns throughout the park. Often they grow on the edges of root balls, the root balls of long-dead cedar trees, where not even a stump remains. My mental model is that a certain kind of mycelial network is metabolizing the roots, and as it metabolizes, when the water is abundant and conditions are right it sorta takes a breath, and exhales a flush of mushrooms.

They might develop for 3 days, eventually open up and drop spores, and then fade back into the grass. Any time they’re above ground, as long as they’ve not gotten stepped on or smashed or dried out, they could be good for the plucking and eating.

It can go from ‘no mushrooms are visible anywhere’ to ‘wow that is a lot of mushrooms’ overnight.

some people call the patterns in the grass, left by these underground root balls ‘fairy circles’. They’re sometimes faint, sometimes quite distinct. This is exactly where the mushrooms seem to like growing.

This single blob of mushrooms might be 3 lbs of mushrooms, maybe more:

The abundance is distinctive.

I have made mushrooms an intentional, specifically sought out part of my diet for years. Now I don’t even pay for them, and I eat even more of them than I did before.

Sometimes at the park I pick just a few handfuls of mushrooms, enough for me to add to my meals regularly for a few days. Some single mushrooms are so big that I will eat only half of it with my next meal.

Sometimes I’ve collected many more mushrooms than I could eat in just a few days, and I suspect mushrooms are unlikely to grow year-round, so I baked them down in the oven at 350 degrees for a while, then vacuum sealed them and stored them in the freezer.

I have already been surprised by how late into the year the mushrooms continue to grow and the mycelial networks continue to fruit. (It’s currently almost November, and I picked a kilo of mushrooms a few minutes ago, I’ll eat them later today, two days ago I filled a reusable grocery bag, it was like 12 lbs of mushrooms)

Mushrooms and fungal networks are cool

I’ve been a huge fan of mushrooms for many years, but it was only a few days ago that I learned after encountering this document, that mushrooms technically contain all of the essential amino acids, just some sort of amino acid that cannot be manufactured within the body.

The documentary fantastic fungi has tons of beautiful time laps photography/videography of fruiting fungal networks.

The book Entangled Life: How Fungi Make Our Worlds, Change Our Minds & Shape Our Futures is worth snagging at a library, too.

something feels particularly right about at least a few bites of mushroom in with the egg and veggies that I eat every day.

Fat is cool, too

Seems worth mentioning that I also make sure to be eating what feels like an adequate amount of fat, in the form of olive oil and coconut oil.

I spoon a tablespoon or 2 of coconut oil into meals as I sauté them, often enough, or add coconut cream (stored in the freezer if I don’t use it all) to some dishes, and virtually always pour 10-20 grams of olive oil (a few table spoons) on every meal I have.

this piece is turning into being about more than just mushrooms, so sorry

I also would advocate for kimchi, sourkrout or kombucha. any sort of fermented food. I make my own kombucha, so at least every few days will have at least a few sips of kombucha. I imagine nice things happening in my gut when I do that. I don’t think more than a tablespoon or two is needed for a full dose of active culture of whatever is being fermented. So, i try to get at least a little fermented food with most meals. I have a friend that gets me costco kimchi containers, and i’ll make one last for a while. I will make my own kimchi someday. I love fermented food of all types, and appreciate what my gut bacteria do for me. I try to be a reasonable enough host for that collection of bacteria.

Fat is the main portion of the structure of our a brain such as ours, as well as the spinal cord. Fat also can be metabolized by the liver for energy generation stuff, same same but different as sugar can be metabolized for energy. ²

Foraged mushrooms vs capitalism

Anyway… Mushrooms now compromise a meaningful amount of my food consumption, and it’s been over a year since I’ve bought mushrooms.

I didn’t get into this with the intent of decapitalizing any my food consumption, and I note now having done so it feels satisfying. In the same way that hunting an animal might engender a sense of accomplishment, or raising plants in a garden might spark accomplishment, finding mushrooms in the park feels appealing. I had nothing to do with any part of the process besides showing up and plucking the mushroom, and there isn’t even time invested. This is vastly preferable to all forms of gardening I’ve ever encountered in my life, until now.

I dislike capitalism, and would like to see dramatically less of the human experienced affected by the intrusion of currency, money, into the human experience³

I’d love to see infinite food available for all. I don’t believe in political authority, but if there WAS a case for political authority, it would look like ‘using resources to cafe for those in need’, and providing food to anyone who wanted it checks the book. I wish no other bombs or cars were ever allowed to be created again until everyone in the USA, maybe in the world, who wanted food, had it, for free, no obligations or dehumanizations involved, and american cities were covered again with streetcars, trams, rail transport. Such is my fantasy.

Foraging Mushrooms respectfully

I dislike capitalism, and I dislike colonialism, slavery, and genocide, and all of those things are sorta opposed to healthy relationships (between us and ourselves, us and each other, us and the land people live on top of and travel around on).

Robin Wall Kimmerer wrote this article: ‘the honorable harvest’.

I’ve read many books, but never Braiding Sweetgrass: Indigenous Wisdom, Scientific Knowledge, and the Teachings of Plants, also by by Robin Wall Kimmerer. I’m listening to the audiobook right now, and it’s a delight.

Foraging has sometimes been a less-than-innocuous activity when it comes to issues of political power, but it’s also the activity that quite directly encourages a certain respectful relationship between people and nature. It’s a stark contrast to agriculture, which is synonymous with the State and its armies and slave labor.

For some fascinating takes on the state and the people living beyond the state, and foraging and the many other forms of how life existed outside the strictures of agriculture & the state, I suggest James C Scott. I just finished The Art of Not Being Governed: An Anarchist History of Upland Southeast Asia and found it to be exceptional. (It’s nominally an examination of state formation and un-formation in a region centering on modern-day thailand.) It deserves its own blog post. ⁴

Long-term storage

I’ve also only recently made some big improvements in how I prep the results of this foraging.

Sometimes I’ve collected far more than I can eat in a few days.

< as I type these words I have a ten pound bag of mushrooms in my fridge waiting for prep - add the photo >

Bake mushrooms whole
Pan fry whole too
Treat like steaks - crispy on the outside, seasoned, v uniform and juicy on the inside. Different energy than chopping them up, prior way I prepped all mushrooms.

< insert photo of using torch to sear outsides of the mushrooms >

They seem to bake and do even better in the fridge with this treatment, which makes sense.

When they’re growing in the earth, and maintain their shape and structure, they grow successfully, but if smushed or cut or kicked or they already dropped spores and are thus expired, some other stuff, depending on the stage of development, different sorts of failure set in. An undisturbed, normally-growing mycilial network fruiting body is a neat capsule that retains mosture and structure with a pretty distinctive outermost shell that’s a bit flexible and rigid at the same time.

So far I believe mushrooms have been spotted in the park surprisingly many months of the year. Through November for sure, and it was sometime this last spring I spotted them for the first time this season.

I have noticed that I spend less at the grocery store; I no longer buy mushrooms, which per-pound are sorta expensive, and since it’s abundant and free to me, I have shifted my regular veggie mix (a rotation of broccoli, zucchini, squash, cauliflower, cabbage, asparagus, brussel sprouts…) more towards mushrooms.

I mostly don’t eat meat⁵, and low-key I wish more did the same. I dislike enslavement and forced/coerced suffering. Chattel slavery was some shit, in the American south, that energy continues today and something in the meat industry too willingly embraces enslavement in so many directions. I stopped eating meat in 2017 after reading Eating Animals. I’ve tried to reduce the amount of enslavement and suffering my eating habits rely upon. If you are what you eat, I wonder what I am. I eat almost exclusively mushrooms, eggs, cruciferous veggies, olive oil and coconut oil.

Now that mushrooms are available abundantly, for free, three blocks from my house, well, my meat consumption continues to stay at almost 0, and my mushroom spending is 0, but my mushroom consumption has gone up, nicely.

Mushrooms and amino acids

I didn’t know until quite recently that mushrooms seem to contain all essential amino acids (and maybe the non-essential ones, too). I didn’t know that. I’ve been wanting to reduce my egg consumption, so when I heard this my ears perked up, and I’m sorta playing with reducing egg consumption. I’ve done some days where I eat only two eggs, so far so good. ⁶

How to prep & eat mushrooms, deliciously

No one likes to feel dirt or sand in their teeth, so give the mushrooms a good scrub in water. Maybe two scrubs. Trim the stem where it connected to the mycilial network, to remove the dirt embedded there. Or, scrub it all off. Or trim it, sorta making the shape of the tip of a pencil, to remove the dirt from that part of the mushroom. Rinse it with water again.

I’d been cooking and eating these mushrooms for almost a year before I ever ate one raw. The thought had never crossed my mind. Then it did, and I was immediately brought back, taste-wise, to the experience of eating salads with raw mushrooms on them. Familiar and normal. Now I eat these (after rinsing them) raw, regularly, and I don’t know why I didn’t start long ago.

They are fine raw, but finer with some olive oil and salt. Usually I’d chop and sauté them, and they go great with onions, garlic, ginger. maybe some broccoli or zucchini. once everything is soft add some eggs, and drizzle some olive oil when plating. It’s delicious.

They can be sliced up before cooking, but my most recent innovation has been to not slice them up before cooking! I’ve been pleased with the results. Sometimes I’ll slice them up after cooking, like a little fillet.

I’ve recently started cooking them whole, it’s been great:

I’ll probably add more to this post soon. I was noticing big improvements in the cooking part of the mushrooms, and lamented that I’d not even created a single page about them on this website, even though so much of my actual, day-to-day life has been affected, improved, by this encounter.

I’ve told many people about this, in person, but still have not yet encountered a single other person foraging mushrooms for their own use. I hope to someday meet someone else, or many others, doing just this.

I’ve found these mushrooms growing in other parks, too. I don’t know other parks like I know cheesman, but I’ve sometimes spotted some. Maybe explore around wherever you live. I’ll maybe update this if I find other parks with abundant quantities of mushrooms growing in them, especially if agaricus bisporus.

Foraging and pesticides

The city of denver’s website says they don’t use pesticides broadly, and when they do use them, it’s on specific trees, and they place a yellow flag saying ‘pesticides recently applied here’ next to the tree. I’ve occasionally seen the yellow flags, but infrequently.

Additional Reading

Nutritional Quality and Biological Application of Mushroom Protein as a Novel Protein Alternative
Entangled Life: How Fungi Make Our Worlds, Change Our Minds & Shape Our Futures
Yunnan people are currently obsessed with one thing: mushroom foraging in the mountains…【滇西小哥】 (I watched this video a few times when cleaning and prepping my foraged mushrooms)
Eating Animals, Jonathan Foer
Braiding Sweetgrass: Indigenous Wisdom, Scientific Knowledge, and the Teachings of Plants by Robin Wall Kimmerer
The Honorable Harvest (Robin Wall Kimmerer)
Anything by James C Scott

Footnotes

This thing we could call ‘american-style zoning’, or ‘euclidean zoning’, ‘separation of use zoning’, ‘segregated land use zoning’, etc. It’s a scheme where boxes drawn on a map determine quite a lot about what can be built there, and was used to devestating effect all across the greater united states. The original designation for R1 neighborhoods was in a section titled, and I am not kidding in the slightest, ‘race zoning’. It says more: r1 - wh*te, r2 - c*lored. Here’s the link to the whole thing. Here’s a deep link to the above section, and the goal was create something of a mix of enclaves, and reservation-type conditions, and to segregate a city by the fantasy of race. these people used zoning to push all economic activity to the ‘edge’ of the enclave. Everything about it is rooted in this energy to dominate others. It’s why the united states has lost the ‘cultural technology’ of the corner store, a corner store, and we’re all vastly harmed by it.

This pamphlet trying to hype the concept of zoning was written by people who loved the enslavement of others at scale. The mayor of Atlanta! I’m bummed to see so many people tirelessly working on replicating his kinky fantasy of a world separated by race, created by a violent and stupid person, small groups of likeminded people. ↩
The comparisons and contrasts between ingested sugar-based things (any food that is an -ose, like sucrose, glucose, fructose, lactose) as energy and ingested fatty things as energy is riveting. I wrote a thing about wearing a continuous glucose monitor. The experiences and observations from that monitor continue to be some of the more interesting and impactful-in-an-ongoing-way of my life. Sorta like psychedelics, or an experience of the numinous. I walked away from the experience with an increased gratitude and appreciation for what my own body did for me, when it comes to energy generation, digestion, energy storage, response to exercise, etc. managing blood sugar levels, raising it when exercising, lowering it via insulin or activity if I ate carby stuff. ↩
I sometimes entertain the idea in my mind of starting a little ‘forage mushrooms from cheesman park’ group. When it’s producing mushrooms, hundreds of pounds of mushrooms can be found in the park. Could represent meaningful money savings from some people. Many, many people could be fed. ↩
This book deserves its own book review, for now I’ll copy/paste a sentiment I agreed with, from this comment:

It covers far too much to try to sum up. I found the most thought-provoking chapters to be the three last.

Though in fact he calls one of them chapter 6 ½, because he’s just feeling his way: it’s on **‘Orality, Writing and Texts’, and talks about possible attitudes to writing that go dead against civilized assumptions. Might a people reject writing, the orthodoxy of a text, that is a foundation-stone of states, and feel they are better off with oral history?

That was fascinating, and the next chapter is ‘Ethnogenesis: A Radical Constructionist Case’ on the artificiality or fictionality of tribes. He comes at this from two sides. Administrators have to order populations into tribes that weren’t there beforehand; but the peoples themselves have uses for a fictional ethnicity – several uses that Scott explores. This chapter includes the why of state mimicry, or what he calls ‘cosmological bluster’ – where tribal peoples take on the trappings of states, in ways that may be more subversive than subservient. Lastly, ‘Prophets of Renewal’, on the question of how and why (and what type of) religion has served in revolts of the marginal and the dispossessed. This is a terrific chapter, that does begin on explanations, and those might not be what you thought. (emphasis added)

↩
i do technically eat some meat. it’s been almost a decade since I’ve eaten cows, pigs, or chickens, and I wish those industries were dramatically reduced, or eliminated. Native people ate bison, i say stop growing corn and turn all the land back to native people and bison herds. Ending concentrated animal feeding operations/slaughterhouses would be so cool.

95% of my meat consumption is the occasional consumption of sardines and salmon. Even then, I eat these much less than weekly. At restaurants, I might order something with shrimp (the other 5%). Otherwise, a vegetarian dish for me.

before 2017 I ate lots of cows, pigs, chickens, then read eating animals, and stopped all meat consumption. I do eat and have always have eaten a lot of eggs, and sorta wish I ate less. Not even none, but have not yet found my way to low egg consumption. I eat at least three a day, maybe closer to 4 or 5 sometimes. I don’t drink milk, I sometimes eat cheese, certainly sometimes eat ice cream, and a little heavy cream is sometimes tasty in the coffee. I do not avoid butter. ↩
I still don’t quite know what an amino acid is. Why is there exactly 22 of them for human animals? can existing amino acids be reused or recycled? My mental model was always that my body can mostly fabricate the amino acids it needs, and the stuff it cannot, it’ll scavenge it from the environment or the self (reusing, recycling). My mental model of a cell is not that it ever spontaneously falls apart and washes away, but that the structural elements can be taken apart and re-used. Like taking down a brick wall, moving the bricks, and re-building the wall. I also happen to view eggs as a source of everything the body could need, so if I needed external sources of compounds or molecules, I’d get it in eggs. I don’t begrudge my body at all if it decided to take down some tissue to reuse the components elsewhere. autophagy is cool, I theorize that I might get more of it than some people, because my protein consumption is not so high, + the occasional intermittent fasting vibe. ↩

More skilled

I Learnt — Thu, 30 Oct 2025 10:57:00 GMT

Seth Godin asks

If someone with more skill and dedication took over your work, how many ways could they make it better?

Vannevar

Brian Sunter — Thu, 30 Oct 2025 10:48:25 GMT

Local RAG search for markdown files. SQLite FTS5 keyword search and HNSW vector search fused with Reciprocal Rank Fusion, running fully offline on a local ONNX embedding model.

Bayesian A/B testing is not immune to peeking

Alex Molas Blog — Thu, 30 Oct 2025 02:00:00 GMT

Introduction Over the last few months at RevenueCat I’ve been building a statistical framework to flag when an A/B test has reached statistical significance. I went through the usual literature, including Evan Miller’s posts. In his well known “How Not to Run an A/B Test” there’s a claim that with Bayesian experiment design you can stop at any time and still make valid inferences, and that you don’t need a fixed sample size to get a valid result. I’ve read this claim in other posts. The impression I got is that you can peek as often as you want, stop the moment the posterior clears a threshold (eg $P(A>B) > 0.95$), and you won’t inflate false positives. And this is not correct. If you’re an expert in Bayesian statistics this is probably obvious, but it wasn’t for me. So I decided to run some simulations to see what really happens, and I’m sharing the results here in case it can be useful for others.

What I Saw Around The Curve

Second Thoughts — Thu, 30 Oct 2025 01:49:51 GMT

Notes from the near-future of AI

ChatGPT Scrapes Google and Leaks Prompts

Quantable Analytics — Wed, 29 Oct 2025 21:13:03 GMT

UPDATE: Thanks to Ars Technica’s reporting on this story, OpenAI has claimed to have fixed the leakage but that this only affected a “small number” of prompts. Based upon what OpenAI has said and the speed of the response I think it’s most likely that the glitch was related to the layer of ChatGPT that […]

The post ChatGPT Scrapes Google and Leaks Prompts appeared first on Quantable Analytics.

My Evil Plan if I Were Mark Zuckerberg

Welcome to my weblog on Newbeelearn — Wed, 29 Oct 2025 20:31:23 GMT

TLDR; leaked secret evil plan of mark zuckerberg

YouTube as a precursor

I Learnt — Wed, 29 Oct 2025 19:48:00 GMT

Could the history of YouTube indicate the path that AI is going to be follow for the generation of applications?

Disasters I've seen in a microservices world, part II

João Alves — Wed, 29 Oct 2025 18:39:53 GMT

When I first wrote about microservice disasters, I thought we'd eventually "solve" them, with better tooling, frameworks, and operational maturity. We didn't. We just learned to live with the chaos. Distributed systems will always surprise you: timeouts, retries, and fallacies don't disappear; they just shift shape. Maybe that's the real lesson: software engineering isn't about eliminating uncertainty, but managing it gracefully.

Being part of the Runtime team at Adevinta, building an internal Kubernetes-as-a-service for the rest of the company, gave me a perspective on all the things software engineers build atop distributed systems. After all, is a Platform any good if we're not surprised by what people build? I don't think so.

So, today I'm adding four disasters I've seen first-hand to the other six.

Disaster #7: more services than engineers

When I join a new team or domain, one of the first things I ask for is a walkthrough of the architecture. It's not just curiosity, it's survival. It helps me form a mental model of the feature set, complexity, technical debt, and the real boundaries of what's possible. It's also the best way to connect with Individual Contributors (ICs) and understand how they perceive the system.

Time and time again, I'm baffled by how many teams have more services than engineers. And I don't mean "slightly more". I'm talking about four or five services per person. It sounds impressive on a slide deck — "we've fully modularized our platform!" —, until you realize it means one human being is the de facto owner, operator, and incident responder for half a dozen distributed systems.

If you're Google, Uber, or any of the large tech companies with a world-class internal platform, you can get away with that. You have automatic dependency upgrades, standardized templates, CI/CD abstractions, service ownership dashboards, and well-staffed SRE teams. But most other companies? Even with good automation, this setup is a slow-motion disaster.

Each new service adds cognitive overhead. Think about new pipelines, dashboards, alerts, secrets, dependencies, and runtime contexts. Every change multiplies the blast radius. And when the team reorganizes (because they always do), those services become orphaned. No one remembers what they do, but everyone is too afraid to turn them off. They just keep running.

Disaster #8: the gateway to hell

One of the hardest things to get right in distributed systems is the gateway layer, the connective tissue between your frontends and microservices, or between services themselves. In theory, it's a clean abstraction. In practice, it's a pressure cooker for all the complexity we didn't want to deal with elsewhere.

Authentication and authorization are perfect examples. They sound simple until you need to combine multiple identity providers, fine-grained permissions, and multi-tenant scoping. All while remaining both secure and fast. Many teams underestimate how expensive those operations are, and worse, they overload their gateways with them. Suddenly, what was meant to be a lightweight routing layer becomes a CPU-bound monolith performing crypto operations and access checks for every request.

Then comes the other side of the coin: thread pools and I/O behavior. Gateways are typically the first and last hop in a request chain. If you don't understand whether your downstream services are CPU-bound or I/O-bound, you'll misconfigure your pools and timeouts. It's incredibly common to see gateways with default thread counts inherited from some Spring Boot starter or Node.js template, serving hundreds of concurrent connections. The result? Latency spikes, thread starvation, and cascading failures that ripple across the fleet.

Building reliable gateways requires more than YAML and good intentions. It demands understanding backpressure, circuit breakers, and how your runtime behaves under load. Most teams don't realize how fragile their setup is until a single misconfigured pool takes down the entire production environment.

Disaster #9: technology sprawl

Every company says they value "engineering autonomy." Few realize what that really means. Given enough time and freedom, engineers will pick every possible framework, runtime, and library known to humankind. Kotlin coroutines here, Vert.x there, Go services running next to a Rust API that only one person still understands. It's like visiting a theme park of ideas, until something breaks and no one remembers how to restart the ride.

This kind of technology sprawl doesn't happen because engineers are careless. It occurs because leadership allows — or even encourages it! — under the banner of innovation. But innovation without accountability leads to entropy. Every new stack is a new operational surface, a new security vector, a new onboarding cost. And when reorgs happen — spoiler: they always do! — these snowflake systems become landmines.

The only person who can fix them might have just left the company. Flight risk, in this context, isn't just a people problem; it's a systems problem. Each "unique" tech choice creates a dependency on a human being. Lose that person, and you lose that piece of the system's knowledge graph.

Fortunately, this is one area where things are getting better. AI-assisted code understanding tools, architecture reviews, and internal tech radars are helping teams regain visibility. They don't eliminate sprawl, but they make it more transparent. And sometimes, just seeing the mess clearly is the first step to cleaning it up.

Disaster #10: when the org chart becomes your architecture

This one is slightly related to Disaster #7, but with an organizational twist. I've talked about it countless times with Thibault. When teams start creating dozens of microservices, they often organize them by team ownership rather than by domain. So you end up with things like "Payments team", "Growth team", and so on. They deploy their services into their team's Kubernetes namespace, their Terraform stack lives in their team's AWS account, and all the dashboards and alarms are wired to the team's Slack channel.

It looks tidy on paper. Every team has clear ownership, autonomy, and a sandbox that the team can break without bothering others until the org chart changes. Because it constantly changes.

A new VP of Engineering brings fresh ideas for efficiency and alignment. A reorg happens. Suddenly, the "Payments team" that owned two bounded contexts — say, Payments and Subscriptions — is split into two. One team keeps Payments; another inherits Subscriptions. But all the infrastructure, namespaces, and IAM policies are still tangled under the old account. So now you have two options:

Share infrastructure, creating a new kind of dependency hell.
Migrate everything, which is just a fancy way of saying "congratulations, you've bought yourself a six-month migration project."

Neither option feels good. The first one slows teams down and creates confusion about ownership ("who fixes this alarm now?"). The second burns time and budget on work that delivers no user-facing value.

This problem goes deeper than just cloud accounts or namespaces. It's about coupling architecture to the org chart. When Conway's Law meets reorgs, you get architectural drift. Systems that once mirrored the team structure start to outlive it, and suddenly, your entire platform's topology reflects who reported to whom in 2021.

It's one of the most expensive kinds of technical debt. It's invisible until the (non-existent) reorg budget suddenly triples.

The new normal

Four years later, I'm still seeing the same patterns, just dressed in different frameworks, clouds, and YAML dialects. The tools evolved, but the fundamentals didn't: distributed systems remain distributed, humans remain human, and complexity remains undefeated.

What's coming next will make this even more interesting. We're now trying to build AI agents: autonomous, stateful systems that communicate with each other, make probabilistic decisions, and respond to unpredictable inputs. In other words: distributed systems with opinions. What could go wrong? The same fallacies apply, just at a different layer. Latency, consistency, observability, determinism. None of them magically disappears because the component now "thinks."

As an industry, we'll go through the same cycle again: early excitement, creative disasters, tooling booms, and eventually, a bit of humility.

Whether it's microservices or AI agents, the story doesn't really change. We're still trying to make chaotic systems behave predictably. And we're pretending we can fully control them.

The good news? We'll keep learning. The bad news? We'll probably learn it the hard way.

— João

PS: I'm building RotaHog, a lightweight tool for managing team rotation schedules (on-call, support shifts, release duties, etc.). Try it if you're tired of hacking spreadsheets or Slack threads together. I'd love your feedback!

If you enjoyed this article, consider subscribing to the newsletter and buying me a coffee.

Reimagining Customer Support with GenAI

Adnan's Random bytes — Wed, 29 Oct 2025 13:58:23 GMT

This post is part of the GenAI Series. If you’ve ever worked in customer support, you know the feeling. It’s 2 PM on a Wednesday. Your inbox is overflowing. A customer just sent their third “following up” email. Your manager wants to know why last week’s tickets are still open. And somewhere in the back of your mind, you’re wondering: Why does this feel so hard? Here’s the thing: Most support teams aren’t failing because people aren’t trying hard enough. They’re struggling because the systems we’ve built over years of “making do” were never designed to handle today’s volume, complexity, or customer expectations. And the stakes? They’ve never been higher. According to Zendesk Benchmark data, more than half of consumers will switch to a competitor after just one bad experience. Not three strikes. One. Even more concerning? Research from Coveo shows that 56% won’t even tell you they’re unhappy. They’ll just quietly leave. At the company where I work, customers would often blame our support teams for delays, but the reality was more complicated. Sometimes it was us. Sometimes it was waiting on the customer. Sometimes it was dependencies on other teams. But without clear evidence, these conversations turned into “he said, she said” situations that damaged trust on both sides. So I built a tool that generates complete reports explaining exactly why each ticket got delayed. It scans through ticket histories, internal notes, response times, and handoffs to create an objective timeline. No more finger-pointing. Just facts. The impact was immediate. Our teams could defend themselves when delays weren’t their fault, and more importantly, we could identify and fix the real bottlenecks when they were on us. But here’s what surprised me: that one tool opened my eyes to a much bigger opportunity. If AI could bring this level of clarity to delays, what else could it do? I started researching, and what I found was a complete transformation waiting to happen across customer support. This series is everything I’ve learned about where GenAI can actually make a difference (not just the chatbot hype you’ve heard a thousand times). Let’s start with the problems. The Real Pain Points (And Why They Matter) 1. Repetitive Queries You’ve seen it a hundred times: “Where’s my order?” “How do I reset my password?” “Can I get a refund?” These questions make up 40–60% of your ticket volume. Your agents could answer them in their sleep, and honestly, that’s part of the problem. When half your day is spent copy-pasting the same responses, burnout isn’t far behind. What AI can do: Smart, intent-aware chatbots can handle these queries automatically by training on your actual support conversations, not generic templates. Your team gets their time back for the problems that actually need a human touch. 2. Delayed Resolutions Ever watched an agent hunt through three different systems, two Slack channels, and an outdated wiki just to find an answer? Or worse, wait two days for engineering to respond before they can even help the customer? These delays aren’t anyone’s fault. They’re just the reality of working with fragmented information and cross-team dependencies. But here’s what customers experience: waiting. And waiting erodes trust faster than almost anything else. What AI can do: AI can scan ticket histories, internal notes, and past conversations in seconds. It can tell you why a ticket got delayed (like “waiting on engineering response, average lag: 42 hours”) so you can fix the bottleneck, not just the symptom. (This was my starting point, and once I saw how powerful this transparency was for both our teams and our customers, I couldn’t unsee all the other places AI could help.) 3. Inconsistent Tone & Quality Some agents are naturally warm and empathetic. Others are efficient but might come across as cold. Some overexplain. Others are too brief. It’s not that anyone’s doing it wrong. Everyone just has their own style. But when customers interact with your brand, they expect consistency. And when 73% of consumers will switch to a competitor after multiple bad experiences (Zendesk), every interaction counts. What AI can do: Real-time coaching that gently nudges agents: “This might sound a bit defensive. Try acknowledging their frustration first.” It’s like having an editor looking over your shoulder, one that helps you sound like your best self. 4. Poor Root Cause Visibility Ask most support managers what’s causing delays, and you’ll get hunches. “Engineering handoffs take forever.” “The knowledge base is outdated.” “We’re understaffed.” But without data, it’s hard to know where to focus or to make the case for change. What AI can do: AI can analyze thousands of tickets and surface patterns: “40% of this month’s delays were caused by missing API documentation.” Suddenly, you’re not guessing anymore. You’re making decisions based on what’s actually happening. 5. Knowledge Fragmentation The answer exists somewhere. Maybe it’s in a Slack thread from six months ago. Maybe someone wrote it in Notion. Maybe it’s just living in one senior agent’s brain. This isn’t sustainable, and when that person leaves, the knowledge walks out with them. What AI can do: AI-powered knowledge hubs can pull information from everywhere (Slack, docs, past tickets) and surface it exactly when agents need it. Even better? When AI spots a gap (like 15 tickets about the same issue with no help article), it can draft one automatically. 6. Customer Frustration Long wait times. Generic responses. Being transferred three times. We’ve all been on the receiving end of bad support, and we know how quickly it erodes trust. Your agents aren’t trying to frustrate customers. But when they’re drowning in volume, quality suffers. And remember: most unhappy customers won’t complain. They’ll just leave. Silently. What AI can do: Sentiment analysis can detect when a customer’s frustration is escalating (even if they’re being polite) and flag the ticket for immediate attention. Catch the problem early, and you can turn a potential detractor into a loyal advocate. 7. Agent Training Overload New hires are eager to help. But learning your product, your tools, your processes? That takes weeks, sometimes months. Meanwhile, they’re hesitant to ask “dumb questions,” so they either guess or escalate everything. What AI can do: An AI mentor that new agents can ask anything: “How do I process a refund for a canceled subscription?” Instant, accurate answers without bothering their overwhelmed teammates. 8. The SLA Panic Cycle Most teams only notice a problem when a ticket is about to breach its SLA. Then it’s all hands on deck, scrambling to close it before the deadline. This reactive approach is exhausting, and it doesn’t actually improve the customer experience. What AI can do: Predictive AI can flag tickets that are likely to breach within the first 15 minutes. You get ahead of the problem instead of constantly playing catch-up. 9. Hidden Patterns in Delays Sometimes tickets take longer for reasons no one notices. Maybe it’s a specific product SKU. Maybe it’s tickets that come in during a certain timezone. Maybe it’s a particular integration that’s secretly broken. These patterns are invisible until AI finds them. What AI can do: Pattern recognition tools can reveal connections like: “Tickets mentioning SSO integration have 3x longer resolution times.” Now you know where to focus your improvement efforts. The Big Picture GenAI isn’t just about deploying a chatbot and calling it a day. It’s about building intelligent systems that: ✅ Understand what customers actually mean, not just what they say ✅ Predict problems before they spiral ✅ Coach your team to be more empathetic and effective ✅ Keep your knowledge base alive and useful (automatically) ✅ Uncover the root causes slowing everything down In other words: AI helps you move from reactive firefighting to proactive problem-solving. And here’s what matters most: your agents get to spend less time on repetitive busywork and more time actually connecting with customers. Because at the end of the day, that’s what great support is really about. What’s Coming Next Over the next few weeks, we’ll break down each of these pain points in detail. We’ll show you real examples, practical tools, and implementation strategies (not theoretical fluff, but things you can actually use). What pain point hits closest to home for you? Reply and let me know. I read every message. If you like this post, then you should subscribe to my blog for future updates. * indicates required Email Address *

The post Reimagining Customer Support with GenAI first appeared on Adnan's Random bytes.

Some thoughts on improving India

Ananth's Reflections — Wed, 29 Oct 2025 13:36:58 GMT

I’m living in the US for the past 10 years.

Obligation Elimination And The Power Of Saying No

Ashley Janssen Consulting — Wed, 29 Oct 2025 12:00:09 GMT

Learn more about the opportunity cost of saying yes, how to figure out which obligations to eliminate, and how to know when to say no.

Reflecting on Venting

🦉 olshansky 🦁 — Wed, 29 Oct 2025 05:35:31 GMT

A Read Through `On Venting`

I have a close friend to whom I vent every once in a while.

He recently shared a post he wrote called On Venting.

I immediately understood why he responds to all of my non-venting messages and pretends as if the vents never happened:

When folks interact with me, I often skip past the emotional complaints.

I like to think I do the following, but it’s probably only true half the time—at best:

Import JavaScript like it’s 2026

phpied.com — Wed, 29 Oct 2025 03:13:18 GMT

I started this new project called sightread.org to generate music to practice sight reading. (Still early days, it works with rhythms only). I wanted to go for no build process and modern JS and modern HTML. How modern is modern? IE8? IE10? In my head when I think "modern" it always brings an image of […]

Training Claude to Compensate for My Neurological Patterns

Zachary Proser — Wed, 29 Oct 2025 02:00:00 GMT

How I'm systematically teaching an AI system to compensate for specific ADHD/autism processing patterns—building collaborative intelligence that works with my neurology.

What I can change

Jamie’s blog — Wed, 29 Oct 2025 02:00:00 GMT

God, grant me the serenity to accept the things I cannot change, the courage to change the things I can, and the wisdom to know the difference.

I think everyone has heard that before. I was vaguely familiar with it but it’s not a particularly core part of my life.

Or so I thought.

I’ve been reflecting a bit on larger-scale changes which are happening around me: the major geopolitical changes we’re seeing, the rise of AI, the latest Ruby drama, climate change, etc.

I realise now that my default response is to understand how to navigate this world as it is, not change it to how I believe it should be. Perhaps it’s the swimmer and the stoic in me: I’m swimming in the sea, adjusting my stroke, sighting for landmarks, and ploughing on because I can’t change the conditions. I can only change how I respond to them.

I can’t wish for the wind to stop blowing waves into my face when I breathe but I can turn my head to the other side. I can’t change the water temperature but I can have predicted these conditions and trained for it (or worn a wetsuit). I can’t make the fog lift but I can remember the course, sight more frequently, and follow other swimmers or the directions of kayakers. I can’t do anything when a storm cancels a swim but I can be ready if it doesn’t.

Others, I’ve noticed, are not like this. Perhaps stronger or braver, they rage against this tide. They scream at the injustice of it—as if life was supposed to be fair—and they rally others to the cause. They see a delta between how the world is and how they believe the world should be, and they believe they can change it. I guess? Or, at least, they seem to expend significant energy complaining about it.

I don’t.

That person is who they are. That company does what it does. That country is what it is. That government is exactly what they said they were. That situation happened. That technology does what it does. This industry is going that way. The climate is getting worse. Those incentives are aligned to inevitably produce this outcome. People are going to be who they are. I am who I am.

I can’t change much of that.

I’m so small in this world that all I can do is figure out what has happened or predict what’s going to happen, how that affects me (if at all), and how I react to it. I have control over myself, some influence over others around me, and a vanishingly small effect on the rest of the world.

This is mostly how I’m thinking about AI: It’s inevitable. There is so much money aligned behind AI that the incentives for powerful people, and frankly the entire US economy, mean that AI is going to be pushed and pushed and pushed. And even with the simplest of tasks and the most naive implementation, the hint at value is there. This is not crypto. This is not a solution searching for a problem that normal people have (who aren’t money launderers)¹. AI is going to be widely available, widely distributed, and widely integrated.

Once you accept that AI is going to be a thing, you can start figuring out if it’s going to affect you (undoubtedly, yes). Then you can start plotting how you’ll react to it.

The future is the sea, AI is the prevailing weather conditions, and your career is the course you need to plot. What are you going to do about it? How will you adapt your stroke? How will you change your mindset? What need equipment or skills do you need? Or are you withdrawing from the race?

Putting your head in the sand, ignoring AI, protesting against its use or the crimes of its evangelical creators, or hoping it’ll go away is a losing strategy. It’s exhausting, it’s depressing, and it simply delays your actual reaction to the situation. It’s not getting you anywhere.

Stop screaming into the storm and start learning how to swim in it.

Ironically, I actually think AI might provide a legitimate use-case for crypto if stablecoins are used for Agent-to-Agent commerce. We’ll see if that actually becomes a thing. It still feels like a solution searching for a problem. ↩

AWS Sagemaker Bring-Your-Own-Container (BYOC) with Pixi

Londogard Blog — Wed, 29 Oct 2025 02:00:00 GMT

To run your own container in AWS Sagemaker (Training Job) it’s required to have mamba. So how would you use pixi instead?

It’s quite straight-forward, first add micromamba as part of your dependencies in pixi.toml. Then you update your docker to something like this:

FROM --platform=linux/amd64 ghcr.io/pixi

COPY pixi.toml pixi.lock ./

ENV PIP_DEFAULT_TIMEOUT=360
ENV UV_HTTP_TIMEOUT=360
RUN pixi install --frozen # use .lock-file

# === IMPORTANT PART ===
# Link micromamba as mamba, to support AWS sagemaker
# Replace <default> with the environment name you use

# 1. link environments `micromamba` to `mamba`
RUN ln -s /.pixi/envs/default/bin/micromamba /.pixi/envs/default/bin/mamba
# 2. Add pixi to PATH
ENV PATH="/.pixi/envs/default/bin:${PATH}"
# 3. Add MAMBA_ROOT_PREFIX
ENV MAMBA_ROOT_PREFIX=/.pixi

# This isn't used by AWS but nice-to-have for local testing
# RUN pixi shell-hook -e default > /shell-hook.sh
# RUN echo 'exec "$@"' >> /shell-hook.sh
# ENTRYPOINT ["/bin/bash", "/shell-hook.sh"]

This’ll create a Docker image that’s usable inside AWS Sagemaker and let you keep using pixi throughout your whole dev-cycle, remote and local!

Perhaps there’s a easier way, if you know one please share in comments below! 👇

That’s it for now,
~Hampus Londögård

Fetch The Flag 2023 GetHub Writeup

Justus Perlwitz — Wed, 29 Oct 2025 02:00:00 GMT

This is a writeup for the Fetch The Flag 2023 GetHub challenge.

Ruby Community Reflections

Ryan Bigg’s Blog — Wed, 29 Oct 2025 02:00:00 GMT

Content warning: suicide

Understanding Python Protocols - Structural Subtyping in Practice

Krystian Safjan's Blog — Wed, 29 Oct 2025 01:00:00 GMT

Learn how Python protocols using structural subtyping in PEP 544 allow for flexible, decoupled code by defining shapes through method signatures rather than class inheritance. Explore examples of implementing read-only attributes and optional methods within protocols.

Fix macOS Wake-On-LAN with this one weird trick

jonandnic dot com — Tue, 28 Oct 2025 17:18:31 GMT

You've probably seen the checkbox in Settings for "Wake for network access", but unless you've stumbled on the secret handshake, you might not have seen the feature working.

The hidden burden of motor neurons

Padirac Innovations' blog — Tue, 28 Oct 2025 11:55:58 GMT

Human large motor neurons, like those in the spinal cord’s ventral horn, are more vulnerable in ALS, while oculomotor neurons remain relatively unaffected, mirroring zebrafish observations. [3]:...

Elite AI-Assisted Coding, Cohort 1 Wrap

Eleanor on Everything — Tue, 28 Oct 2025 10:52:43 GMT

The first cohort of Elite AI-Assisted Coding just wrapped up, and honestly, Isaac and I are blown away.

Scaling Elections with GPUs and Mojo across Nvidia and AMD 🔥

Ash's Blog — Tue, 28 Oct 2025 02:00:00 GMT

Taking the computationally expensive Schulze voting method from theory to practice on GPUs — exploring parallel algorithms, hardware optimizations, and why Mojo surprised me.

Photos from October 28th, 2025

cjlm.ca — Tue, 28 Oct 2025 02:00:00 GMT

Fetch The Flag 2023 Sparky Writeup

Justus Perlwitz — Tue, 28 Oct 2025 02:00:00 GMT

This is a writeup for the Fetch The Flag 2023 Sparky challenge.

Windows on ARM: One Year Later

Jason Eckert's Website and Blog — Tue, 28 Oct 2025 02:00:00 GMT

A little over a year ago, I got my hands on a Snapdragon Dev Kit for Windows powered by Qualcomm’s new Snapdragon X Elite CPU, and that inspired me to share my first impressions of Windows on ARM. Back then, the platform felt polished but had a few quirks. Now, after a full year of daily use, here’s how it’s held up.

A year ago, I was curious whether this emerging platform could hold up in day-to-day use, particularly in tech-heavy environments like software development and data science – for example, creating and running AI models. While the platform felt polished, there were some limitations: hardcore gaming required more than the integrated Adreno GPU, nested virtualization in Hyper-V wasn’t supported, and a few apps were unavailable for ARM, requiring emulation.

How I made my wrestling sign for WWE Crown Jewel Perth

utf9k — Mon, 27 Oct 2025 10:00:00 GMT

My first ever wrestling sign

Defolding My Love For 2D Gamedev

MC.Info — Mon, 27 Oct 2025 09:00:00 GMT

Season two of Hacking the Grepson is all about making a game. After some consideration, the decision to use Love2D and/or Defold, two different game engines, was made and a concentrated effort to tinker with both of them has begun.

पढ्नु गर्नु

Bhupal's Web Page — Mon, 27 Oct 2025 08:55:27 GMT

पढ्ने कुरा यति धेरै छन् तै, मान्छेहरु सोचेर बस्छन ! गर्ने कुराहरु यति धेरै छन् तै, मान्छेहरु सोचेर बस्छन ! महान र विद्वान व्यक्तिहरुले नसोचेको के होला यो दुनियामा सोच्न बाँकी के नै होला ? आफ्नै सोच बाहेक अन्य विचारको स्रोतहरुमा बिश्वास नभएर हो? आस्था नभएर हो? नत्र मान्छेले, खुरुखुरु शास्त्रहरु (पुस्तक) पढ्नु अनि आफुले […]

The Diplomat: Season 3

🦉 olshansky 🦁 — Mon, 27 Oct 2025 06:40:46 GMT

Review of The Diplomat: Season 3

Claude as My External Brain: Autistic, ADHD, and Finally Supported

Zachary Proser — Mon, 27 Oct 2025 02:00:00 GMT

How I use Claude as an external brain and assistant—combining voice, agents, and a hardened CI/CD lane—to support an autistic mind with severe ADHD.

Walking and Talking in the Woods with AI: The Future of Untethered Software Development

Zachary Proser — Mon, 27 Oct 2025 02:00:00 GMT

A DevSecCon 2025 keynote summary: orchestrate voice, agents, and a hardened CI/CD lane so you can think where you think best—while background agents safely ship production-grade code.

Walking and Talking in the Woods with AI: The Future of Untethered Software Development

Zachary Proser — Mon, 27 Oct 2025 02:00:00 GMT

DevSecCon 2025 keynote on untethered AI-driven software development in the wild.

time-zones now on MELPA. Do I have your support?

xenodium.com @alvaro — Mon, 27 Oct 2025 02:00:00 GMT

A little over a week ago, I introduced time-zones, an Emacs utility to easily check city times around the world. Today, I'm happy to report, the package has been accepted into MELPA.

It's been wonderful to see how well time-zones was received on Reddit.

✓ You asked for MELPA publishing and I delivered.

✓ You asked for DST display and I delivered.

✓ You asked for a UTC picker and I delivered.

✓ You asked for UTC offset display and I delivered.

✓ You asked for Windows support and I delivered.

✓ You asked for help and bug fixes and I delivered.

Will you make the work sustainable?

Bringing features and improving our beloved text editor takes time and effort. time-zones isn't my first package, I've also published a bunch of Emacs packages. Will you help make this work sustainable?

How to List the Content of a Public Google Drive Folder

Yasha Solutions — Mon, 27 Oct 2025 02:00:00 GMT

Learn how to list files in a public Google Drive folder using Python without authentication

[RIDGELINE] Full Days and the Long Walk

Craig Mod — Writer + Photographer — Mon, 27 Oct 2025 02:00:00 GMT

Ridgeline subscribers —

Hello from the other side of my ~220 kilometer walk through the Kiso Valley.

I sent a shorter version of this newsletter as the last issue of the (the entire walk is) Between Two Mountains pop-up newsletter. This version is quite expanded. The archives of the B2M pop-up are available to SPECIAL PROJECTS members on the members’ site. And if you’d like to follow along in my digital footsteps, the GPX file of the walk is here.

Founder vs Operator

🦉 olshansky 🦁 — Sun, 26 Oct 2025 23:00:26 GMT

Founders create problems. Operators solve them.

I’ve met a lot of executives and CTOs who resonate with two things:

They like to solve puzzles.
They like to be given an end goal and just make it happen.

The job of a founder is to identify opportunities (i.e. problems), set a vision for what a solution looks like, and build a team that’s enabled to get there.

That idea, of course, comes with plenty of qualifiers and caveats. It simply defines a founder’s end goal, not their day-to-day.

Swift Sings: MDX-Net Vocal Splits and RVC Voice Conversion On-Device with ONNX/CoreML

Navan's Archive — Sun, 26 Oct 2025 21:07:00 GMT

Using MDX-Net and Retrieval Based Voice Conversion (RVC) in Swift via ONNX and CoreML (+ Accelerate and AVFoundation)

The Book is Here

Satisfice, Inc. — Sun, 26 Oct 2025 07:50:21 GMT

I’ve received a few inquiries so here’s the deal… I’m not saying that you should want a signed copy of my book, Taking Testing Seriously, but if you did want one, there’s a way to get one directly. Use eBay. Here’s the link: https://www.ebay.com/itm/406321656118 It costs a little more than going to Amazon, because my […]

Inside Amazon's Engineering Culture: Lessons from Their Senior Principals

🦉 olshansky 🦁 — Sun, 26 Oct 2025 04:59:06 GMT

Last week, Amazon quietly hosted a private open house for senior engineering leaders at its Seattle headquarters. About fifty people gathered to discuss how Amazon makes technical decisions at scale-the kind you don’t hear about in press releases or leadership books.

I didn’t know what to expect, but who would say no to dinner with smart people and deep conversations in the Seattle Spheres?¹

This is my version of a great night out 🥂.

Timing Wheels

Parth Parikh's Blog — Sun, 26 Oct 2025 03:00:00 GMT

In this blog-post, we will start by discussing the evolution of timekeeping, leading all the way to its use in computers. We will then introduce software timer modules, and explain timing wheels as a fast and memory efficient way to manage timers. Finally, we will discuss both the classic Linux timer wheel implementation and its modern variant.

Science Is the Belief in the Ignorance of Experts

Home — Sun, 26 Oct 2025 03:00:00 GMT

That line from Richard Feynman has never been more relevant, so far.

By the power of grayscale!

zserge's blog — Sun, 26 Oct 2025 03:00:00 GMT

When people talk about computer vision, they usually think of OpenCV or deep neural networks like YOLO. But in most cases, doing computer vision implies understanding of the core algorithms, so you can use or adapt them for your own needs. I wanted to see how far I could go by stripping computer vision down to the bare minimum: only grayscale 8-bit images, no fancy data structures, plain old C, some byte arrays and a single header file.

Claude, Teach Me Something

Hugo Tunius - Blog — Sun, 26 Oct 2025 02:00:00 GMT

I’ve been experimenting with a new Claude workflow as an alternative to doom scrolling. It leverages what LLMs do best: non-determinism and text. I call it “Teach me something”.

Thinking About Thinking With LLMs

Davis Haupt's Blog — Sat, 25 Oct 2025 20:00:00 GMT

After reading Developing our position on AI from the Recurse Center, the corresponding entry in my newsletter grew long enough I’ve decided to break it out into a full blog post. Above and beyond its specific findings, I think the post charts a path for a more civil and considered mode of discussion that we should all strive for on the Internet and in our own lives.

I’ve long been fascinated by the Recurse Center. Throughout my career I’ve been consistently impressed with alums I’ve crossed paths with, so I’m not particularly surprised that probably the most balanced and thoughtful take on AI and software engineering that I’ve read so far has come out of Recurse.

Discourse on the Internet

I think the article presents a great way to deal with contentious issues within organizations and how to write about those issues publicly. First, listen to everyone. Then, acknowledge disagreements and emphasize nuance to make an effort to find common ground.

The goal doesn’t need to be having The Correct Take at every moment. People have different life experiences which often leads them to different top-line beliefs. But beyond those headlines, where reasonable people state anything from “we’ll all be living in ASI-powered utopia by 2028” to “LLMs are slurping up all our fresh water”, there is a surprising amount of common ground.

In the case of this article, most people agreed that using LLMs to learn new things needs to be done with some caution.

Step-Functions in Abstractions

This paragraph from the post really resonated with me:

[T]utorials and teachers can only get you so far. Ultimately, you must build your own mental structures. Stack Overflow can be a helpful resource, but blindly following or copy-pasting from it does little to help you learn. While you can get a lot farther mindlessly using LLMs than Stack Overflow, the same principle holds true.

The comparison to StackOverflow is one that I’ve seen pop up again and again in discussions around LLMs. While LLMs can feel revolutionary, it’s not the first time we’ve seen a step change in software development resources.

Google made the skill of searching and skimming manuals for reference materials almost obsolete. O’Reilly still exists, but reference books are a much smaller part of an engineer’s education than shorter-form blog posts focused on specific tasks¹.

StackOverflow made it possible to accomplish many common coding tasks without much upfront thinking. Most consider copy/pasting StackOverflow answers to be an unfortunate shortcut. StackOverflow filled a niche, but it didn’t obviate the need for a deep understanding.

Software engineering has always had a component focused on automating “white collar” human work like airline logistics, processing payroll, or organizing and maintaining libraries². Programming as a profession has never been immune to this — assemblers automated away calculating memory offsets for jumping to procedures; garbage collectors automated memory management; Google Search changed what it meant to RTFM.

New tools always make it easier to code with a shallower understanding of the system. Claude Code, Cursor and their ilk are bringing programming closer to natural language just like C and Java and Python once did.

This is a good thing! It’ll lead to the continued democratization of programming and ever more people in conversation with computers. But I don’t think this changes the fundamental reality that the best programmers aren’t the ones that make the widest use of the highest abstractions. That’ll continue to be those who dig down and understand what’s happening at a deeper level — that understanding will always lead to more deft use of any tools that programmers have at their disposal.

All four of types of documentation certainly existed before the advent of search engines, but shorter-form content thrives in ranked searches and recommendation algorithms. ↩
The ones filled with stacks and stacks of books, not the ones with pre-written functions you can call from your programs ↩

Free Will: A Rich Fairy Tale

Stories by Trend Guardian on Medium — Sat, 25 Oct 2025 10:12:11 GMT

The 1st World Myth of Choice

Dispelling the harmful bias of the fortunate

“Man make plans, and God laughs.” — Old Yiddish proverb

Is choice an illusion? Hint: Time is linear; multiverses are unproven. Source

Ever wondered why the 1% define the status quo? Why we idolize and follow their dogmas? From the Matthew effect to Pareto’s principle, the wealth gap reality is clear, but it doesn’t need to be. At the heart of these injustices lies a central tenet: free will. A doctrine preached by the rich to deceive many, especially the poor.

The idea that we have the ability to choose between different courses of action without outside influence is called free will — aka the idea of “choice”. It is an age-old dilemma tackling our sense of agency and control in the universe, but when combined with individualistic values, can result in harmful ramifications.

American discourse has used this idea to justify inequality, healthcare, and faith; for it is easier to blame & judge than to listen & help. Here is a simple test: ask anybody from a 3rd world country about “choice” and this worldview crumbles down. While citizens of rich nations take simple amenities for granted, the rest of the world cannot even fathom these privileges.

Americans are also more likely than the rest of the world (73%) to believe that hard work pays off. This belief coincides with a Pew study* that surveyed them on this statement: “Success in life is determined by forces outside our control” — below are graphs from income and religious preference:

*Screenshots taken while site was still active. Source

This comparison reveals a small insight: the majority of the upper class and Protestant Christians share a common ground — i.e. the richer and/or more religious you are, the more likely you will believe in free will. Is free will exclusively American or is it a bias of the rich and religious?

“Rich” can also be in health, status, knowledge, opportunities, time, etc. — a power dynamic is key.

On “In Data We Trust”, a study was initiated to see if Protestant ideals had an effect on a nation’s prosperity. Free will is often preached at churches to explain everything from the existence of evil, to faith justification and material success.

The idea persists because it is tied to freedom and responsibility: “If I am not in control, why should I take responsibility for my actions?” Yet copious studies from science, economics, mathematics (1), and theology seem to point by consilience, to the impossibility of free will.

Are we victims of our culture?

Americans love the idea of freedom, often confused with “choice”. “Choice” is pervasive in popular culture like books, movies and games. Take a sample from Disney’s Marvel series What If?, or Netflix’s Ozark (spot the word “choice” in their introductions) — both targeted toward families, the foundation for our values. This pattern expands onto more serious issues, from gender and abortion to vaccines: “Gender is a choice”, “My body, my choice”. Be warned, popularity does not equate truth. Repetition makes a lie come true and propagandists know this.

Consider the possibility that the “choice ideology” might be a subconscious construct of propaganda

There seems to be a correlation between how comfortable someone is in life and their tendency to believe in this bias. This popular rhetoric is construed to deceive if we don’t question our reality. Our tendency to connect free will to responsibility might be due to the logical fallacy of correlation vs. causation; yet both ideas can be mutually exclusive.

There is a book that proposes a challenging thesis: we might not have free will, but we do have responsibility. In an age where truth is no longer valued as we put our faith in the rich, can we unmask the deep biases and blind spots in our society? Perhaps this inquiry might bridge the gap between the privileged and the destitute.

By the author: The Truth Formula

Bonuses
1. The power of brands and neuromarketing
2. Six corporations control 90% of American media
3. Job “hopping”, leaving, staying
4. What Homelessness Is Like (priceconomics link)
5. The value of good teeth
6. Is Success Luck or Hard Work?

Pelican on a Bike - Raytracer Edition

Beetle Space — Sat, 25 Oct 2025 10:00:00 GMT

Simon Willison has a light-hearted benchmark for evaluating LLMs. He asks them to draw a Pelican riding on a bicycle in SVG format.

I decided to do a twist on this. How good are LLMs at drawing a Pelican on a bicycle using the POV-Ray ray tracer?

My prompt …

Starminder v4

Nik Kantar — Sat, 25 Oct 2025 03:00:00 GMT

I relaunched Starminder two weeks ago, and it eagerly awaits your signup.

ghidra-delinker-extension and boricj do ACM CCS 2025

boricj’s entropy-increasing blog — Sat, 25 Oct 2025 03:00:00 GMT

What?

Shuzo Fujimoto’s 103rd Birthday

Origami by Michał Kosmulski — Sat, 25 Oct 2025 01:00:00 GMT

Shuzo Fujimoto, portrait in three-quarter profile, Koichi Tateishi in the background. Picture by Robert Lang, taken on May 4th 2006. October 27th, 2025, will mark the 103rd anniversary of Shuzo Fujimoto’s birth. On this occasion, I’m publishing this picture of Shuzo Fujimoto, taken by Robert Lang on May 4th, 2006, at Fujimoto’s home in Sasayama, Japan.

One month with ZSA's Navigator

Matthew Gaudet — Sat, 25 Oct 2025 00:51:29 GMT

About a month ago I got my ZSA Navigator, and have been using it every work day since, so I thought I would leave some semi-structured thoughts at this point.

First and foremost I should say: It took me at least two and a half weeks of puttering around before I was remotely happy. There’s a few things that I did right, and a few things that aren’t yet supported which would have sped that up, but it’s not a “wow, you’re instantly capable” kind of addition. However, if you’re the kind of person who bought a Voyager, I suspect you already are OK with spending some time figuring things out.

Using a Trackball

I’ve long been trackball curious, but I’ve never made the switch. I am incredibly happy with Apple’s touchpads and their acceleration curves, but I have never gotten an amazing setup with my trackpad and my Voyager. Lots of motion, awkward hand positioning from having the trackpad between my Voyager halves. its’ particurly an issue when it comes to having more tent on the Voyager -- it starts to feel like the trackpad is in a hole.

Some people have really nice clever solutions here, and honestly I may look more into them, but I really thought the trackball looked good.

Using the Navigator has shown me that there’s a bit of a mixed bag here. On the one hand, the the ball is quite nice. Haptically I really like it, and I like the easier access and fixed position relative to a Voyager half.

However, dialing in sensitivity has been a journey: If the sensitivity is too low, it feels like it takes forever to get your cursor anywhere, but if you set it too high, a trackball is very sensitive to your hand’s natural motion and hitting a target becomes a challenges of its own! At my preferred setting right now, things feel fine, yet I do feel like it’s still a bit too much jumpiness (there’s an aspect which feels almost like there’s too coarse a motion quantum too, but it’s purely a feeling)

Another interesting problem is momentum. I think Apple’s momentum based scrolling is remarkable. I had hoped that I would have physical momentum on my side with the trackball, but it turns out that the ball isn’t heavy enough or there’s too much friction, and so the ball doesn’t really show enough momentum compared to what I’m used to.

A Trackball With a Mouse For keys

Maybe I don’t brain good, but it’s been a month now, and I still am regularly getting mode confusion and problems. I’ve managed to fix quite a bit of the worst of it by banishing some of the most galling buttons to never-never-land, but it’s far from perfect.

Let me give you an example: The default mouse layout puts scroll lock on T -- but given the default dwell time, I kept hitting CMD-T while the mouse layer was active, setting scroll lock and then not actually opening a new tab like intended. So shorten the dwell time right? Except, then, a moment’s hesitation when trying to do a click with f means you’re filling a channel with mistaken f strokes. Hilariously frustrating when you’re in a shared doc with colleagues as they watch you drop f in random paragraphs.

So I turned off auto deactivate. Now I need to click to deactivate. But this still means that if I jostle the ball or move my mouse for some other reason, I have to remember to hit a key to get the keyboard back into ‘being a keyboard mode’. But it’s fine if you hit most keys, because they’re transparent down to layer 0... except unimportant keys... like d,f and g. Oops. I moved scroll lock to r, so r is also no good.

To know if the mouse layer is active I set a layer colour, which helps. However, you can’t set a layer colour for scroll lock which would be helpful when you move your mouse and seemingly nothing happens, because you’re not in a scrollable container, but you’ve accidentally turned on scroll lock.

So you’re left in this situation where you’re never 100% confident what each button or what the ball will do.

Am I sure that this isn’t just me being dumb? I think this might just be the challenge of wanting to get too much into the same device.

Physical layout

I opened complaining a bit about my trackpad feeling like it was down a well. But the default mount for the Navigator has the opposite feeling -- the ball is so high, you have to reach for it. I ended up getting my 3D printing guy to print me the official thumb shell. Strongly prefer this layout actually, though I miss my higher tent, and I keep thinking maybe I should get him to print me this with more tent.

Lots of Complaining.... you getting rid of it?

No, I think I’m going to keep it for now. When it’s working well it’s actually super lovely! I just think I need to keep tweaking some of this to get even more comfortable with it.

We’ll see what the update looks like in 8 months.

how to draw a tetrapod

Tony Finch's blog — Sat, 25 Oct 2025 00:40:51 GMT

Concrete tetrapods are used to dissipate wave energy in coastal defences.

There’s a bit of a craze for making tetrapod-shaped things: recently I’ve seen people making a plush tetrapod and a tetrapod lamp. So I thought it might be fun to model one.

I found a nice way to describe tetrapods that relies on very few arbitrary aesthetic choices.

Click here to play with an animated tetrapod which I made using three.js. (You can see its source code too.)

Click to skip to the recipe

background and reference material

There is a patent for tetrapods written by the inventors of the tetrapod, Pierre Danel and Paul Anglès d’Auriac. It says,

The half angle a at the apex of the cone corresponding to one leg is between 9° and 14° while the leg length base width ratio b/c for each leg is between 0.85 and 1.15 and is preferably substantially 1/1.

One manufacturer has a diagram suggesting a taper of 10°.

A lot of pictures of tetrapods (one, two, three) have chunky chamfers at the ends of the legs. In some cases it looked to me like the angle of the chamfer matches the angle of the edges of the tetrahedron that the tetrapod is constructed from, which is the same as the angle of the faces of the cube that enclose the tetrahedron.

a surprising experiment

So I thought I would try constructing a tetrapod from the corners of a cube inwards.

My eyeball guesstimate sketch produced a result that’s amazingly neat. It’s the main reason I’m writing this blog post!

Using build123d and CQ-editor, I started with a cube centred on the origin enclosing a tetrahedron, with a common vertex at (100,100,100). I drew a pair of circles near the common vertex, just touching the faces of the cube and edges of the tetrahedron. These circles outlined where I thought the edges of the chamfer might be.

Using a taper angle of 10°, I found another circle centred on the origin that would be the base of the leg. I drew truncated cones to make the leg and chamfer, and replicated them to the three other axes of the tetrahedron.

With a bit of fettling of the sizes of the first two circles, I had a very plausible tetrapod!

To validate this sketch, I found the diameter of the circle around the leg near the centre of the cube where it just touches the x,y,z axes, and the distance from that circle to the end of the leg.

To my surprise, the width and length of the leg both came out very close to 100!

It’s good that they are about the same, because that’s what the inventors of the tetrapod specified. That means my eyeball guesstimate got the proportions about right. What’s amazing is that they match half the side length of the cube that I started with!

recipe for a tetrapod

You can read the source code for a tetrapod drawn using three.js and play with the resulting animation.

preliminaries

Pick a size.

The size is the length and diameter of each tetrapod leg, half the height of the tetrapod as it is constructed balancing on two legs, and a few percent less than half the height of the tetrapod when it’s standing on three legs.
The tetrapod is constructed inside a cube centred at the origin, with vertices at (± size, ± size, ± size). Inside the cube is a tetrahedron, and the tetrapod’s legs point towards its vertices.

In the picture above, the cube is shaded green, and the tetrahedron is outlined with straight red lines.
We will construct the positive leg along its main axis, the vector from the origin to the common vertex (+size, +size, +size).

The three other legs will be cloned from the positive leg.
The leg is constructed from truncated cones.

A cone is described by its taper, r / a = tan(θ), where a is the distance from the apex of the cone, and r is the radius of the circular section of the cone at that distance.

Every cone’s axis is the main axis, but their apex varies.
A cone is truncated by a circle with radius r and distance d from the origin along the main axis.

(Note that the apex distance a and origin distance d differ when the apex of the cone is not at the origin.)
We need two scaffolding cones.

The axis cone has its apex at the orign and its sides just touch the x,y,z axes.
```
axis_taper = sqrt(2)
```
derivation
z = (0,0,1)
xyz = (1,1,1)
z · xyz = |z| |xyz| cos(θ)
1 = 1 * sqrt(3) * cos(θ)
a / h = cos(θ) = sqrt(1/3)
r² = h² − a² = |z|² − a² = 1 − 1/3
tan(θ) = r / a = sqrt(2/3) / sqrt(1/3) = sqrt(2)

The face cone has its apex at the common vertex. Its sides just touch the faces of the cube along the same lines as the edges of the tetrahedron.
```
apex_d = size * sqrt(3)
face_taper = sqrt(1/2)
```
derivation
xy = (1,1,0)
xyz = (1,1,1)
xy · xyz = |xy| |xyz| cos(θ)
2 = sqrt(2) * sqrt(3) * cos(θ)
a / h = cos(θ) = sqrt(2/3)
r² = h² − a² = |xy|² − a² = 2 − 2*2/3
tan(θ) = r / a = sqrt(2/3) / sqrt(4/3) = sqrt(1/2)

circles

The leg is constructed from four circles: waist, thigh, ankle, sole. In the picture above, you can see the thigh, ankle, and sole circles outlined in red. The waist is hidden inside.

As required by the inventors of the tetrapod, our chosen size is equal to the diameter of the thigh, and to the distance between the thigh and the sole.

The thigh circles just touch each other at the x,y,z axes.

The foot of the tetrapod, between the ankle and the sole, is the chamfered part. It is a section of the face cone.

The ankle circle is chosen so that the taper of the main part of the leg is about 10°. It turns out that a nice round number, r = size / 3, makes the taper 10.41°.

To fill in the core of the tetrapod, between the thigh circles of the four legs, we will extrapolate the leg taper to find the waist circle whose centre is the origin.

Hence,

Locate the thigh circle from its radius in the axis cone
```
thigh_r = size / 2
thigh_d = 0 + thigh_r / axis_taper
```

Locate the ankle circle from its radius in the face cone

ankle_r = size / 3
ankle_d = apex_d - ankle_r / face_taper

The thigh circle and leg length determine the position of the sole circle, from which we get its radius
```
sole_d = thigh_d + size
sole_r = (apex_d - sole_d) * face_taper
```

The thigh and ankle give us the taper of the leg

leg_taper = (thigh_r - ankle_r)
          / (ankle_d - thigh_d)

Extrapolate back to the origin to find the radius of the waist
```
waist_d = 0
waist_r = thigh_r + thigh_d * leg_taper
```

legs

Make the positive leg from two truncated cones:

one between the waist and ankle,

one between the ankle and sole.
To make another leg, take a copy of the positive leg and rotate it 180° about the x or y or z axis.

Do this for all three axes to get all of the legs.

The legs overlap where their waists spread out around the origin. Conveniently, the legs meet at planes, so we can clip at these planes to make a model where they don’t overlap.

The positive leg meets the other legs at the three planes through the origin with normals:

    (1,1,0)
    (1,0,1)
    (0,1,1)

vital statistics

When standing on three legs with one leg vertical, this tetrapod is

2.09 * size tall
2.52 * size max wide
2.25 * size min wide

The radii of the key circles of the leg are

1/2 * size thigh
1/3 * size ankle
0.27 * size sole

The radii from the vertical axis to the ends of the base legs are

1.08 * size to point touching the ground
1.37 * size to furthest point

The taper of the leg is 10.4°.

The underside of the tetrapod is surprisingly close to flat.

0.17 * size between the ground and the cusp between the legs
9.0° angle between skin of legs and ground

The middle of each face of the tetrahedron is close to the core of the tetrapod. That’s partly because of the small 9° angle between the legs and the ground, which is parallel to a face of the tetrahedron. It’s also because the thigh circles protrude a tiny amount through each face, because they are slightly larger than the circles that just touch the x,y,z axes and the faces of the tetrahedron. These inner circles have a radius of sqrt(6/25) * size.

The cusp where three legs meet is slightly inside the face, by 0.015 * size.
The thigh circles are larger than the inner circles by 0.010 * size.

epilogue

It almost feels like the shape of the tetrapod was discovered rather than designed.

A tetrahedron nested in a cube is a fun framework for a shape. Using half the cube’s side length to determine the length and width of the legs seems like a natural choice. Maybe the choice was based on how close sqrt(6/25) and 1/2 are?

A third of the side length for the taper is a plausible option that turns out quite elegant. Maybe the chamfer at the foot is designed? I like the way it both hints at the cube from which it was constructed, and presumably has good engineering properties such as making the corner less prone to damage and easier to remove from its mould.

One thing I have not yet managed to work out (except by punting the problem to a CAD kernel) is exactly what ellipse is formed where the legs intersect. Investigations continue…

davepeck.org — Fri, 24 Oct 2025 19:35:00 GMT

Now that t-strings are part of Python 3.14, I've seen a lot of people ask the question: "should I use them?"

The short answer is "probably not yet." Template strings are powerful but still very new. They'll only start to become useful when libraries and frameworks (like tdom and t-sql) that fundamentally require them become more widespread.

A related question I've seen: "do t-strings replace f-strings?" The answer is "no." F-strings remain the best and most common way to do simple string formatting in Python. T-strings are useful in less common cases when you need to keep track of which parts of a string are static and which are dynamic.

If you're actively developing a library or framework that can benefit from t-strings, then by all means start using them now. But for general application development, I think it's best to wait until the ecosystem has had time to mature.

Palau Web

extua — Fri, 24 Oct 2025 19:00:00 GMT

The domain name I currently use for this website is www.extua.pw.

Exploring Concurrency in Java - From Threads to Structured Concurrency

GeekWare - Daniel Pecos Martínez — Fri, 24 Oct 2025 17:00:00 GMT

Java’s journey in concurrency has been long and fascinating — evolving from manually managed threads to lightweight virtual threads and structured concurrency in the modern era. In this post, we’ll explore several approaches to running tasks concurrently, showing how each step improves simplicity, readability, and scalability.

You can run these examples with Java 25 directly from .java source files:

java Example.java

[!NOTE] For the scope of this post, we will not cover good old Threads (OS managed threads), but rather we’ll start directly using Virtual Threads (JVM managed threads).

1. Starting with the Basics — The Raw `Thread`

Here, we just want to run a simple task concurrently using a Thread (a virtual one). It’s the most fundamental building block for concurrency in Java.

void main() throws InterruptedException {
    Thread worker = Thread.startVirtualThread(() -> {
        IO.println("Running in a separate thread: " + Thread.currentThread().getName());
    });

    worker.join();
    IO.println("Main thread finished.");
}

What’s happening:

We create and start a new virtual thread to execute a task.
join() ensures the main thread waits for it to complete.

2. Thread Pools with `ExecutorService`

In this example, we want to run multiple tasks efficiently using a pool of worker threads. This avoids creating too many threads and lets us manage resources better.

import java.util.concurrent.*;
import java.util.stream.*;

void main() throws Exception {
    try (var executor = Executors.newFixedThreadPool(4)) {
        var futures = IntStream.range(0, 5)
            .mapToObj(i -> executor.submit(() -> {
                Thread.sleep(200);
                return "Task " + i + " done by " + Thread.currentThread().getName();
            }))
            .toList();

        for (var f : futures) IO.println(f.get());
    }
}

What’s happening:

We submit 5 tasks to a pool of 4 threads.
Each task sleeps for a short period and then returns a result.
The main thread retrieves all results via Future.get().

3. Asynchronous Pipelines with `CompletableFuture`

Now, let’s chain asynchronous operations to simulate fetching and processing data in a non-blocking way.

import java.util.concurrent.*;

void main() {
    try (var pool = Executors.newVirtualThreadPerTaskExecutor()) {
        CompletableFuture.supplyAsync(() -> {
            IO.println("Fetching data...");
            sleep(300);
            return "Data";
        }, pool)
        .thenApply(data -> {
            IO.println("Processing " + data);
            return data.length();
        })
        .thenAccept(len -> IO.println("Result length: " + len))
        .join();
    }
}

void sleep(long ms) {
    try { Thread.sleep(ms); } catch (InterruptedException ignored) {}
}

What’s happening:

CompletableFuture runs each step asynchronously.
Results flow from one stage to the next without blocking.
This pattern is powerful for IO-heavy operations.

4. Structured Concurrency — Cleanly Coordinating Subtasks

In this final example, we want to start two subtasks concurrently, wait for both to finish (or cancel the other if one fails), and then combine their results. Structured concurrency provides a safer and clearer way to handle multiple concurrent tasks as part of a single logical operation.

import java.time.Instant;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Subtask;

void main() throws Exception {
    try (var scope = StructuredTaskScope.open()) {
        Subtask<String> users = scope.fork(() -> loadData("users"));
        Subtask<String> orders = scope.fork(() -> loadData("orders"));

        // Wait for both subtasks to complete or for one to fail
        scope.join();

        // If join succeeded, both tasks completed successfully
        IO.println("Results: %s | %s"
                  .formatted(users.get(), orders.get()));
    }
}

String loadData(String type) throws InterruptedException {
    IO.println("Loading %s...".formatted(type));
    Thread.sleep(300);
    return "Loaded %s at %s".formatted(type, Instant.now());
}

[!IMPORTANT] ⚠️ Requires --enable-preview flag in Java 25.

What’s happening:

StructuredTaskScope.open() creates a scope for concurrent subtasks.
Each subtask is typed as Subtask<String> for clarity, using the import.
fork(...) schedules a subtask within the scope.
scope.join() waits for all tasks to finish or cancels others if one fails.
Results are retrieved safely using get().

There more advantages in using Structure Concurrency like scope cancellation, which let’s you handle complex concurrent tasks.

Using Virtual Threads in Spring Boot

With Java 25’s virtual threads and structured concurrency, we’ve seen how to efficiently manage concurrent tasks in standalone applications. These same principles can be applied in modern frameworks like Spring Boot, where server threads handling HTTP requests can also leverage virtual threads. This enables scalable, non-blocking request processing while keeping code readable and maintainable.

Spring Boot 3.2+ supports using virtual threads for handling HTTP requests and other tasks, leveraging Java 19+ Project Loom features. This can greatly improve scalability for IO-bound workloads.

Configuring Virtual Threads

Enabling virtual threads withing Spring is as simple as including a configuration class like the following:

@EnableAsync
@Configuration
public class ThreadConfig {
    @Bean
    public AsyncTaskExecutor applicationTaskExecutor() {
        return new TaskExecutorAdapter(Executors.newVirtualThreadPerTaskExecutor());
    }

    @Bean
    public TomcatProtocolHandlerCustomizer<?> protocolHandlerVirtualThreadExecutorCustomizer() {
        return protocolHandler -> {
            protocolHandler.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
        };
    }
}

Now if you define a new controller like the following:

@RestController
@RequestMapping("/thread")
public class ThreadController {
    @GetMapping("/name")
    public String getThreadName() {
        return Thread.currentThread().toString();
    }
}

and query it:

$ curl -s http://localhost:8080/thread/name
$ VirtualThread[#171]/runnable@ForkJoinPool-1-worker-4

you will be able to validate that indeed the request was handled by an instance of a virtual thread.

You can find a more in depth tutorial about Spring and Virtual Threads here: https://www.baeldung.com/spring-6-virtual-threads

Lessons Learned

Each step improves the developer experience, but also explains what problems the more advanced solution solves:

Threads: Simple but error-prone for multiple tasks.
Executors: Manage resources efficiently.
CompletableFuture: Express pipelines of async work.
Structured Concurrency: Provide clear scoping, automatic cancellation, and simple error handling.

Conclusion

Java now offers a rich toolbox for concurrent programming:

Threads are best for simple, one-off background tasks.
Executors are ideal when controlling the number of active threads.
CompletableFuture shines for composing dependent async tasks.
Structured Concurrency brings order and safety to complex concurrent workflows, aligning with how humans think about tasks and subtasks.

Each approach builds on the last — culminating in a model where concurrency is not just efficient, but also structured, predictable, and readable. Modern Java has never made concurrency feel so approachable.

How to Download Google Spreadsheet as a CSV from a Public URL

Yasha Solutions — Fri, 24 Oct 2025 13:00:00 GMT

Learn how to download public Google Spreadsheets as CSV files using URL parameters and Python scripts

Reflections at 44, Tofu, Ancient Robots, Fanny Crosby

Dan Quach Blog — Fri, 24 Oct 2025 07:18:38 GMT

44 I recently turned 44, and this year resonates more than others for the simple fact that there are two repeating numbers. Other numbers that have come to mind are 22, 44, and 88. At 22, I had just graduated from college with a computer science degree during a mild recession, so none of my…

Why you need to adopt AI (as a software engineer)

Jamie’s blog — Fri, 24 Oct 2025 03:00:00 GMT

Look, I get it, you’re sick to death of hearing about AI. It’s in the news, it’s all over social media, it’s in your favourite apps, and the slop is infecting every corner of your world. You just want to go outside, touch grass, and hope the whole thing goes away.

I have devastating news for you: it’s not going away.

I’m not a AI-evangalist, and I’m not an AI-luddite. I’m something much more nuanced because life, and humans, are messy and not easily categorised into a divisive binary system (hello, US politics!). So I’d like to explain my position with probably an excruciating amount of detail…

What is AI?

AI is a label that you apply to a product that’s worse than the alternative product without AI but it sells for more money

j/k, kinda.

I’m mean, that’s basically a true reflection of our frothy bubble-like times but it’s not particularly useful.

AI is ‘Artificial Intelligence’, a field of academic research that’s almost 70 years old (the term was coined in 1956) and covers everything from speech recognition, robotics, computer vision, agent-based simulations, neural networks, machine learning, genetic algorithms, etc etc. It’s incredibly broad and has been widely taught in colleges for the past 30 years. It is not new.

You will be familiar with many spin-offs of AI and they probably have a place in your home or pocket. Face recogition in your camera. Siri and Alexa. The entire personalised ad industry of the Internet. Book recommendations. Robot vacuums and lawnmowers. Grocery store vouchers. Fitness watches with their activity detection, analysis, and prediction. Gmail spam detection. Voicemail transcription. Google Translate. Non-playable characters in video games.

AI is a broad field spanning all the way from cognitive science to computer science. It’s not all uncanny videos of 6-fingered/three-armed women and mediocre writing. That’s just how the current crop of AI companies, led by OpenAI, have claimed the word for themselves to specifically refer to systems based on Large Language Models (LLMs).

I am more than little bit peeved the ‘AI’ name has been captured by such a narrow part of the field but that battle is lost now. The broader AI field will still be around, providing hugely diverse and interesting research, for decades to come.

It’s this AI-as-LLMs that we need to discuss today.

The last few years can be summarised as:

the latent potential of decades of research into neural networks +
the invention of the transformer architecture +
the availability a massive training corpus in the Internet +
rapidly increased computational power (particularly in GPUs that excel at vector arithmetic) +
and the recognition by commercial companies that injecting large amounts of capital into this machine could now produce meaningfully-useful results.

That’s the basic ingredients for the AI boom we’re experiencing.

Is it all just a stinking pile?

All this enthusiasm has created a lot of noise. There’s a sudden gold rush to figure out what this technology can do and who will pay for it. The enthusiasm is exploding outwards in every direction with lots of energy, no direction, and no consideration for what’s in its way.

Most of it, I think, is dross.

It ranges from the pointless, to the awful, to the dangerous.

Actually, there’s quite a lot of danger because the scariest monsters in the woods (powerful people) just get scarier when you equip them with AI. For example, t’s never been easier or cheaper to create fake videos of presidential candiates dropping out of the election in an effort to subvert democracy.

And there’s a lot more bad news to go around…

Mass copyright-infringement. Forced adoption by companies. Life-altering decisions being made by AI. Incomprehensible amounts of energy usage during a time of a climate crisis. Hallucinations. Six-fingered women. Data centers. A pyramid scheme of investments holding up the entire AI industry (and US economy). Inhuman standards of beauty. Synthetic relationships. AGI. Goodbye searching Google; Hello asking ChatGPT. Life-threatening “medical” advice. AI-suicides. Misinformation. Disinformation. Lack of critical thinking. The mass-transformation of jobs for people into AI-revenue concentrated in just one or two companies. Did I mention the six-fingered women? Sometimes they have three arms too. Vibe-coding. AI-drones. AI-intelligence gathering. AI-enabled browsers snooping on your web activity. Adverts generated on-demand tailored just to you. Sycophantic responses. “I’m sorry, you’re right”. Slop.

That’s a lot to be worried about. A lot to be pissed off about.

But maybe not everything is bad; maybe there is some value to be found in this pile of shit.

What you do need to care about

Right now there is billions of dollars being poured into AI technology. It’s flowing into the few major players (OpenAI, Anthropic), it’s being reinvested inside the likes of Facebook and Google, and it’s trickling down into any company that can slap “AI” on the side of their product. The scale of the money involved is so large that there are convincing arguments that AI is the only thing propping up the US economy right now.

With all this money on the line, there’s a lot of marketing going on and it’s broadly targeted at the decision makers in government and commerce. Every country seems to need an AI strategy now. We’ve seen Shopify, Coinbase, Intercom, and host of other companies go “AI-first”.

Every department in our businesses is being hit with the AI wand, some more successfully than others. Support is moving increasingly to AI-chatbots. Emails are being summarised. Documents are being spruced up. Spreadsheet formulas are being calculated. Automation is being handed off to AI.

And software development? Every single CEO is now asking, “if OpenAI can have AI write 80% of their code, why can’t we?”.

So, what’s our answer?

We’re engineers and inventing, building, using, understanding, and evaluating technologies is what we do. We’re supposed to be curious about this stuff! When someone hands us a puzzle, we figure out how it works.

It takes only a cursory use of an AI-coding tool to realise that there’s definitely some value here as a developer. Perhaps you ask Claude to brainstorm a new approach for processing webhooks in your application. Or you give it a SQL query and ask it to suggest optimisations. Or you just experience an inline suggestion in your editor that autocompletes exactly the next line you were about to type.

There is no denying that there’s the hint of value here. How much? What’s the extent of it’s usefulness? How can we make the most of it? How does it fit into the wider human and technical systems of software development?

Why sitting this out is not an option

I know there are many sceptical developers out there seeing AI either as a threat or a fad.

As I mentioned previously, there’s much not to like about the AI industry right now and we should be rightly concerned about many of the ways it’s being used and the consequent effects on society.

I also think we can separate out those troublesome uses of AI from the AI tools in our own domain. We can simultaneously hold the view that AI videos threaten democracy whilst also believing that AI coding assistants can improve our work—they are not mutually-exclusive views.

Know your enemy

You can’t figure out the value or limitations of AI by ignoring it.

You need to use it and explore it to really understand it and, after giving it a genuine attempt, you are left with two outcomes. In the best case, the AI helps you do your job. Win! In the worst case, you can start to push back against the self-interested AI-crusaders that are red-pilling our entire industry—not with vague thoughts about your “craft” but actual data, knowledge, and experiences you’ve gained using AI.

If you’re an AI-sceptic, then I think it’s imperative you start to learn this new tool because you cannot adequately question something you haven’t spent the time trying to understand. Your arguments will only get stronger as you become an expert in the use of AI.

We’ve seen over and over again that the output of AI systems can look very authentic and convincing to the untrained eye. Ask ChatGPT for a swim set and it’ll give you back one but a real swim coach will poke holes in it. Likewise, a recipe from Claude is perfectly plausible until you try to bake it.

As software engineers, we are both the best placed to evaluate AI’s ability to produce software and the only ones that should do so. If we leave it to the non-technical person that just vibe-coded their first web app, or the CEO’s listening to the latest AI sales pitch, then of course all we’ll hear is how amazing AI is for coding.

If we really want to know how good or bad it is, we need engineers to explore it.

Game theory-ing your career

You might like to wish for a world without AI.

You might like to believe that if you can just ignore it for a few more months then it will all blow over and next year Claude Code and Cursor will be the Bored Apes of 2025: embarrassing, laughable, forgotten.

I think you’re playing a game akin to the Prisoner’s Dilemma with your career.

You’re assuming that if you don’t embrace AI, and no other developer embraces it, then it will die on the vine. Except, if other developers do embrace it and learn how to use it well, they will be more productive and more valuable than you are.

A developer using AI well, will be more productive than a developer without it. A developer using it badly is worse than both. Who are you going to be? Who is a business going to hire?

In the Prisoner’s Dilemma, if one prisoner defects (i.e., embraces AI), then the other prisoner is subjected to an even longer sentence. That’s going to translate to a massive disadvantage in our careers from not getting promotions, to poor performance reviews, to being the first on the firing list, and missing out on job opportunities.

There is no universe where your colleagues and competitors in the job market aren’t going to utilise a tool if it gave them even a 10-20% productivity boost. Wishing for broad non-compliance is a losing strategy.

Bubbles won’t save you

Perhaps you’ve seen the absurd amounts of money being invested in AI, noted that Nvidia appears to basically be paying companies to buy its own product, and you’ve seen the huge losses these companies are racking up with each AI query their users execute.

You think this is a bubble. You’re probably right.

You think that when the bubble bursts, all this AI stuff will go away. You’re wrong.

After the dotcom bubble burst, e-commerce did not die. At the same time in Europe, the telecoms crash did not scupper 3G networks (or 4G, or 5G, or the iPhone, or Android). The housing crash of 2008 didn’t kill off houses, mortgages, or banks.

Those events culled the dead and defective companies but it didn’t off the industry entirely. The bubble will (probably) burst but the useful AI tools will survive.

It might actually improve your (work) life

I was a Java developer for more than 10 years before I discovered Ruby on Rails. That jump from verbose, type-ridden code to method-missing magic and duck-typing was weird. It was very uncomfortable to leave behind the safety of types, compilation, and large comment blocks.

But through that discomfort I discovered a language which I adore and one that fulfills my goals much better than Java did. Equally, adopting Java in the first place back in ’97 wasn’t an easy path: no one was hiring for this very new, and very slow language. The easy choice at the time was C++.

And over the years, we’ve all had to learn new editors, new libraries, new languages, new processes, new version control. Or perhaps you’re still young enough that you haven’t but I’m here to tell you that you will need to learn new things.

That new thing today is AI.

It ~~might~~ will be weird and uncomfortable initially but it might also help improve your work and many of the stressors that come with it.

There is the concern that all this “progress” will put ourselves out of a job once the AI gets good enough. I’m sorry to tell you this (if you have investment in AI companies) but the AI is not going to get good enough. Our teams of developers are not going to be replaced with agents running 24/7 because the fundamental architecture of the systems is statistical not logical. The LLMs have no conceptual model of a system, or its dependencies, its flows, and its constraints. They are “just” a very sophisticated language prediction engine.

It’s incredibly innovative to solve problems by providing the context in natural language, appending the question, then getting the AI to predict the appropriate answer. That’s a stunning development in human technology—but I think it has its limits and we may already be seeing a slow-down in AI progress. Without any conceptual understanding, I think there will always be a role for human minds.

I may be biased because I have always run small teams that punch above their weight, working on systems that our competitors have teams multiple times our size to manage. We achieved this, frankly, by having to be more ruthless about the work we take on. There are are so many good ideas, must-do’s and should-do’s that we don’t do because we’re small and so we have to focus only on the very highest priorities.

I don’t see AI being a threat to our team size in any way. I don’t think we’ll ever need fewer developers but I am enthusiastic about being able to tackle more of those good ideas. I’m hopeful that AI can help us achieve things that were previously too high-effort and lower down our priority list. That we can file off the rough edges which we’ve worked around for years.

I’m actually really hopeful that AI can lower the cognitive load for the team. I wrote recently about how I consider that to be one of our biggest scaling challenges and it’s something that concerns me a lot. A pair of developers might be working on a new feature for a few weeks/months and become familiar with it but it’s a massive workload to then jump to fixing a bug in another area of the app. Can AI, like Neo in The Matrix, load up that context into our brains faster? Can it help us summarise and map out the codebase? Can it remind us about a feature which is dependent on the current behaviour?

I think there is a massive opportunity beyond “AI writes code”. I think constraining your thinking to AI-generated code is frankly, Level 1 thinking. It’s “mid”, as the kids might say. We never hired the programmers with the fastest typing skills (at least, not since the 1950’s). We have never felt like what has held our product back is the lack of a faster typist—because typing is not the bottleneck. And frankly, code is not the end goal either.

We participate in a system of software development. Part of that system is the physical typing of the code into the machine but it’s not even the hard part or interesting part. The hardest bits are knowing what to type: whether that’s product decisions, or architecture decisions, or decisions around maintainability or performance.

This is where the magic happens. In our heads, not our fingers.

Transaction pooling for Postgres with pgcat

Notes on software development — Fri, 24 Oct 2025 03:00:00 GMT

This is an external post of mine. Click here if you are not redirected.

Evolution of Type Hints in Python — From Comments to Inline Typing and Beyond

Krystian Safjan's Blog — Fri, 24 Oct 2025 01:00:00 GMT

Learn about the evolution of type hints in Python, from initial comments to modern inline typing and key features introduced in each major version, enabling powerful static type checking with tools like mypy and pyright.

Keeping performance results in a separate Git branch using `git checkout --orphan`

Krystian Safjan's Blog — Fri, 24 Oct 2025 01:00:00 GMT

Learn how to use git checkout --orphan to create a separate Git branch with no history, ideal for storing performance results or other generated content independently from your codebase. Discover the process and benefits of using orphan branches, including an example GitHub Actions workflow for publishing test results.

A Systems Engineer’s Guide to Benchmarking with RDTSC

Confessions of a Code Addict — Thu, 23 Oct 2025 14:31:05 GMT

A deep dive into rdtsc, instruction stream serialization, and memory fences for precise cycle-level performance measurement.

2025年10月、iPhoneでメルカリ（アプリ版）にログインできない時の対処方法

The Qiqitori Blogs — Thu, 23 Oct 2025 07:48:50 GMT

事象：メルカリのアプリを開いたら突然ログアウトされて、アプリ内でログインしようとしてもログインができない。パスワードが違うとか、そういうのはない。対処方法：サファリでメルカリのブラウザー版（jp.mercari.com）を開いて、ログインする。ログインできる場合、今度はアプリを開いて、ログインボタンを押す。〇〇でログインされています、のようなメッセージが表示されているはず。パスワードを入れなくてもボタンを押すだけでログインができるはず。効果がなかった対処方法：メルカリのアプリを削除して再度インストールしたりもしたが、効果がなかったので関係がないと思います。上の対処方法だけで良いはず。もしかしたらやや古いiPhoneでしか発生しないかもしれません。最新のiOSは17だけど、iPhone 8とかはiOS 16までです。 PS 筆者はiPhoneユーザではありません。

Bending Emacs - Episode 4: Batch renaming files

xenodium.com @alvaro — Thu, 23 Oct 2025 03:00:00 GMT

I'm now a few weeks into my Bending Emacs series. Today I share a new episode.

Bending Emacs Episode 4: Batch renaming files

In this video, I show a few ways of batch renaming files.

The covered flows are:

Dired editable buffers.
Multiple cursors using region-bindings-mode to insert numbers via # (I had a tiny blog entry on this).
We can batch rename using Keyboard Macros too and insert numbers via macro counters.
While I typically use multiple cursors for batch renaming files, I also experimented with dwim-shell-command via M-x dwim-shell-commands-rename-all.

Want more videos?

Liked the video? Please let me know. Got feedback? Leave me some comments.

Please go like my video, share with others, and subscribe to my channel.

If there's enough interest, I'll continue making more videos!

Make it all sustainable

Enjoying this content or my projects? I am an indie dev. Help make it sustainable by ✨sponsoring✨

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

Moon • Art

Muffin Man — Thu, 23 Oct 2025 03:00:00 GMT

After almost two years (life and other projects happened), I finally plotted something new. I resurrected the Moon project, cleaned it up and published it online. Using a technical pen allowed me to add more detail to the image. It reminded me why I love pen plotting so much, and I hope to plot more in the near future.

The code is available on my GitHub, and you can generate your own Moon here.

Created:	October 2025
Size:	30x30cm
Paper:	Fabriano Black Black 300gsm
Pens:	rOtring variant technical pen, Aristo white ink

Your self as a future adversary

Open Indie — Thu, 23 Oct 2025 00:06:20 GMT

Does productivity really increases with ai or it just feels like it?

Welcome to my weblog on Newbeelearn — Wed, 22 Oct 2025 21:31:23 GMT

TLDR; AI productivity is not always real it just feels like it because of lower mental effort

That Time I Trashed The Company Mainframe, And The Lesson I Learned

The Codist — Wed, 22 Oct 2025 18:00:44 GMT

I started my career in the fall of 1981, and in the first six months, I wrote a Jovial language source code formatter in Fortran. I had no prior experience in programming jobs or college programming classes; all I knew was what I had taught myself at home.

That formatter

Movies I went out of my way to watch

Josh Thompson — Wed, 22 Oct 2025 16:00:00 GMT

Introduction

I’ve long liked to accrue certain lists of things I like within certain categories. to list appreciable books invites a similar list for movies and movie-like things.

It feels strange to list all of these movies like this, in some ways, especially the first two documentaries, juxtaposed against some of the other recommendations I have around here.

Some of these shows I found or watched on Netflix, or Jeff Bezos’ internet. Some I searched the pirate bay, and found them there. Example: https://thepiratebay.org/search.php?q=homebodies+1974&cat=0. I’m using Folx as my torrent manager most recently, and NordVPN.

Two documentaries

I just finished an incredible documentary. One of the more substantial I’ve ever seen. By a distinctively-named Joshua Oppenheimer.

Full warning, it’s about recent acts of genocide, ethnic cleansing, a coordinated campaign of mass killing, in Indonesia.

The Act of Killing

The first is about recent, recent events in Indonesia. The Act of Killing, 2012, IMDB. It’s worth skimming the wikipedia page

Useful additional contextual reading could be the book The Jakarta Method, and How to Hide An Empire ¹

The Look of Silence

Oppenheimer did another documentary, after that one, with a similar theme. The Look of Silence, 2014

Joshua Oppenheimer’s documentaries repeatedly land in unexpected ways. he shows interviews of the people who carried out the killing campaigns in Indonesia, and movies they direct about what they did. They speak very openly, and approvingly, of their own actions.

The last ten minutes of The Look of Silence were distinctive. ²

Scooter-themed

Of course I will find something arbitrarily more interesting than otherwise if it involves a Vespa-style scooter, in any way. I like scooters, of course.

I once looked through a few lists of movies having scooters in them, and have since watched at least a few from the list. That’s how I encountered some of the following.

Super Cub

Super Cub is about that super classic motorcycle-style vehicle that is very similar to a scooter. It’s a peaceful show (sorta gives Studio Ghibli at times) about a kid who gets a moped and the unfolding of adventures around it. I found it on Crunchyroll. Here’s a youtube video about the series.

The Interpreter

From the same list (‘all movies that feature scooters in any way’), I encountered The Interpreter, 2005, and quite liked it. It ended up having satisfying and subversive messages throughout, in my opinion. I have a page of notes I took, as I watched it, I might add here or in it’s own post.

The protagonist’s mode of transportation is a scooter, which is how it got on the list of movies I considered watching. I ended up liking the movie a lot more than I expected!

The person’s use of the scooter is unrealistic in only one way - at one point there is a vehicular chase, and the people in the car are able to keep up with the person on the scooter. I kept wishing the scooter user would pass through a gap too narrow for the car and ‘solved’ the problem that way, instead of failing to utilize it’s primary beneficial attribute.

I liked many other parts of the movie, too.

Amalie

wikipedia

2001 French-language romantic comedy film directed by Jean-Pierre Jeunet

absolutely delightful in 100 ways. One of the best I’ve ever seen. Totally unexpected. I was moved, watching it. The description only touches on a portion of what is delightful about it. It’s about love, indeed.

Robert-Moses-themed movies

I still maintain Robert Moses as a delightful conceptual compression for ‘why are things the way they are’ (I.E, why do the greater united states not have any functioning inter/intra-city rail system? why are highways virtually always approved with dollars and permissions and signed contracts and rights of way, seemingly of their own volition? Why is the american urban transit system devoid of the people that built the tram systems of the 1920s?)

Robert moses ran those kinds of people out of the industry. Not only did he employ thousands of engineers, and would fire anyone who advocated for rail transit solutions, but he would instruct the people he issued contracts to, to not hire those people either.

The theme here is movies directly featuring Moses and/or his slum clearance/urban renewal/ethnic cleansing-via-displacement programs.

Often enough reading about it feels very academic, talking about him as an urban planner. He’s so worth discussing because his effect on the world was not academic at all.

I discuss Robert Moses quite a bit more here

Motherless Brooklyn, 2019, Edward Norton

Motherless Brooklyn, 2019 film written, directed, produced by edward norton

a bunch of well known actors, including the person playing robert moses himself.

I wish I could cut the scene that is lifted directly from the power broker. Robert Moses (called Moses Randolph, in this movie) is in a very distinctive way bullying the mayor into giving him another board seat, for instance.

It’s all about Robert Moses, and the way he was destroying a neighborhood and community in pursuit of whatever it was he was pursuing.

Told in a film-noir murder-mystery style. I’ve not (yet) read the book it’s based on (the book titled motherless brooklyn, but I have read the other book it’s obviously based on, The Power Broker: Robert Moses and the Fall of New York City)

“I Won’t Go”

a 1960s-era 25 minute comedy show, titled “I Won’t Go”, available on youtube from the 1960s, depicting a 1950s-era event - the destruction of housing in order to make way for a piece of a highway, an approach to the George Washington Bridge.

I cannot help but think of the land of Palestine, and the many different forms of settler colonialism/occupation pushed into that area. The kinds of justifications used for this sort of action, all around the world. the many similar themes (bulldozers, the different authorities and permits and men with guns)

about an entire municipality and police force evicting an old lady from her house, and her various ways of trying to remain in her own house.

Episode ends with her pointing out to everyone where her house used to be, under what was then turned into an approach road for one of Robert Moses’ bridges.

Homebodies, 1974 satirical comedy horror

Homebodies, 1974 satirical comedy horror film

The film centers on a group of elderly residents in a Cincinnati tenement building who resort to murder when their building is condemned in the wake of urban redevelopment. (wikipedia)

It is, in short, a close up and personal, look at what it was like for the residents of a single building, as they were being made to be without housing. Please note how similar the scenes in that movie are, and the genocide and ethnic cleansing of the palestinian people. The buildings, the torn up streets.

It’s a lovely film. To find it online, something like this might work. Or Jeff Bezos’s internet, i believe.

Lots of bulldozers, urban renewal, wrecking balls, destruction of neighborhoods for highways and luxury apartments. This movie is entirely centered in robert moses’ world.

So many poignant scenes. A cool depiction of a certain use of power, defensive power, perhaps.

No particular theme

Maybe anime?

Delicious in Dungeon

A delightful show, prominently featuring cooking, food prep, foraging, creative problem solving, and lots of other nice things. It keeps delivering delight.

Suzume

Suzume is a delightful film in 100 different ways. I’ve seen it at least three or four times, probably will watch it at least three or four more times.

The Way of the House Husband

wikipedia, also delightful.

Synopsis:

Tatsu, an infamous and feared yakuza boss nicknamed “the Immortal Dragon”, retires from crime to become a househusband so that he can support Miku, his kyariaūman wife. The episodic series depicts a variety of comedic scenarios, typically wherein Tatsu’s banal domestic work as a househusband is juxtaposed against his intimidating personality and appearance, and his frequent run-ins with former yakuza associates and rivals.

It’s delightful, at least the first season or two. I feel like I remember some of the later episodes of the latest season sometimes trailing off, but overall an incredible and delightful show. Subversive in delightful ways!

Charlie Wilson’s War

The story of a person named Charlie, and the war he wanted and got.

Charlie Wilson’s War on IMDB.

Based on the book by the same title.

Similar theme be said to emerge with Killers of the Flower Moon: The Osage Murders and the Birth of the FBI. I believe a movie or a show was released, based on the book, but I’ve not seen it.

Anything by Chalmers Johnson is thematically similar, like Blowback: The Costs and Consequences of American Empire

America’s/american attitude towards the rest of the world is similar to ‘its/their’ attitude towards native people (genocide, displacement, reservation-ization, not unlike Palestine) and the enslaved people that found themselves existing within ‘its’ borders, among “them”.

War, death, enslavement. What a disaster to have unfolded on this continent. I wish it had never been like this.

Additional Reading

Footnotes

I view all acts of mass killings as some enactment of supremacy. I dislike the concept of refinements in the USA of some sorts of supremacy as ‘white supremacy’. The phrase ‘white’ cedes too much to the supremacists. Supremacists of all flavors commit acts of dehumanization, of all flavors, against all/most/enough people they encounter, and themselves, of course.

I’ve always been interested in how and why (and THAT) things go wrong.

Have you yet crossed paths with the Hutu massacre of the people of Tutsi heritage/ethnicity/class? The 1991 genocide in rwanda? in a small number of days, many people were murdered, often-enough by machete. It’s close enough to the distinctively american tradition of night riding. ↩
I’d first written horrifying, in a slow, unfolding way. The subject, who murdered a lot of people and then made a documentary about it, determined that because he played a role in a movie, being pretend-tortured and pretend killed, he had appreciation for the experiences of his victims, and thus was forgiven for his actions!!! Maybe I’m wrong. You watch it and tell me if you get something else. ↩

Karpathy is wrong. Write that post, build that slide deck!

João Alves — Wed, 22 Oct 2025 13:18:05 GMT

This week, Dwarkesh Patel interviewed Andrej Karpathy and covered the future trajectory of Artificial Intelligence (AI). For those who don't know, Karpathy is a leading AI researcher and co-founder of OpenAI.

There's one particular part of the interview that's getting quoted everywhere:

People are interpreting that quote as "don't write, just build." But that's not quite right. Karpathy is absolutely right that building things is the best way to learn. It's how you internalize concepts, face real trade-offs, and gain deep understanding. And he's probably addressing the growing crowd of non-technical folks who talk about AI without ever opening a notebook or writing a line of code.

But here's the nuance he missed: if you're an engineer, writing — or creating a slide deck, or teaching something — is one of the most powerful ways to build understanding. Why? Because explaining something forces clarity. You can't hide behind hand-wavy intuition when your audience knows the topic. You have to go deep. You have to really understand it.

I've been telling this to Individual Contributors (IC) I have managed for years:

Build and talk.

Those two verbs — build and talk — are not opposites. They compound.

Increasing your luck surface area

Jason Roberts once wrote a post called How to Increase Your Luck Surface Area. He explained that the amount of serendipity in your career — your "luck" — is proportional to how much you do multiplied by how much you share:

L(uck) = D(oing) × T(elling)

When you build things you care about (the doing), you develop real expertise. When you share what you've built (the telling), you let others see your energy and your skill — and that attracts opportunities you could never predict.

Image from Jason C. Roberts (Source)

This is why the best engineers don't just focus on building; they also write, speak, document, teach, and share their work. It's not about self-promotion. It's about increasing your visibility. The more people who see your passion and craftsmanship, the more likely you are to encounter serendipitous opportunities.

The hidden win

A few years ago, one of the engineers on my team made a massive impact: he optimized a SQL query that cut response times in half and improved the user experience for millions of people. It also saved the company around €10,000 per month in infrastructure costs. But here's the thing: no one knew. It wasn't on Slack, shared at demo day, nor written up anywhere. It was invisible.

When I asked why, he said, "I didn't think it was worth mentioning. I just fixed it." That's when it clicked for me. As leaders, part of our job is not only to celebrate results, but to create a culture of telling because stories like that are what inspire others to care, to learn, to improve.

Building a culture of sharing

At Adevinta, when I managed the Runtime team, we made "build and talk" part of our work process. But it didn't start with a policy. It began with an example. I was already giving talks, writing about the things we were building, and sharing lessons publicly. When people saw their manager doing it, it suddenly felt normal. Heck, they felt encouraged.

Then I started bringing it up in 1:1s and performance reviews, not as a checkbox, but as a growth opportunity. I'd ask: "What's something you've built recently that others could learn from?" Sometimes that led to an internal Slack post, sometimes a brown-bag talk, and eventually, a few engineers started proposing conference talks or podcast appearances.

Whenever someone shared something, I made sure to celebrate it, in Slack, in our team meetings, and in all-hands. That public recognition mattered. It created a subtle incentive: sharing wasn't extra work; it was impact made visible.

Over time, that small habit compounded. Engineers started writing blog posts, documenting internal learnings, going on podcasts, and speaking at conferences in front of 500+ people. The culture shifted, from quietly shipping great work to proudly telling the story behind it.

Karpathy is right

He builds, and that's why we listen when he talks. But that second part matters just as much. Building gives you skills. Sharing gives you momentum.

The people who grow the fastest aren't just makers. They're translators. They build, reflect, and tell the story so others can follow.

So the next time you ship something, don't close the laptop. Open a doc. Write. Explain. Share.

That's how you turn doing into understanding, and understanding into opportunity.

— João

PS: I’m building RotaHog, a lightweight tool for managing team rotation schedules (on-call, support shifts, release duties, etc.). Try it if you're tired of hacking spreadsheets or Slack threads together. I’d love your feedback!

If you enjoyed this article, consider subscribing to the newsletter and buying me a coffee.

Metabolic shift explains why APOE4 gene carriers have higher Alzheimer's risk

Padirac Innovations' blog — Wed, 22 Oct 2025 11:26:07 GMT

ApoE4 disrupts how neurons use glucose and lipids for energy by impairing their interaction with the receptor sortilin, leading to reduced mitochondrial function and metabolic resilience. Activating...

Leveling Up Teams Fast and Slow

Stay SaaSy — Wed, 22 Oct 2025 09:59:22 GMT

There are many ingredients that go into a smoothly functioning team – hiring, performance management, incentive structures, clear goal setting, streamlined processes, and more. But in the broadest sense I believe that there are two fundamental activities, one fast and one slow, that are essential to a well-functioning team and that anyone can put into place immediately.

I used to like software development... but not anymore

Igor Kulman — Wed, 22 Oct 2025 07:29:12 GMT

I used to really like programming. Making apps, solving problems, seeing something I wrote come alive on a phone. I could spend hours coding and still want more. That feeling is mostly gone now. Somewhere between the meetings, the processes, and the layers of “modern development” I stopped enjoying it. The early days I started programming professionally in 2012, doing Windows Phone 7 apps. It was a strange but exciting time.

Pixi - A year later

Londogard Blog — Wed, 22 Oct 2025 03:00:00 GMT

I’ve been using pixi professionally in my team for a year now, and it has been a pleasure from the start.

N.B. We’ve also been utilizing uv inside the pixi environment.

Brief Intro uv: A faster & better pip. pixi: A faster and better pip+conda (bonus: beats mamba and works for other languages). Uses uv under-the-hood for pip installs.

From the moment I (we) started using uv/pixi something clicked. It’s simple, fast and developer experience (DX) is at a new level. The way pixi seamlessly integrates uv makes me happy about the ecosystem.
The reason I opted to use pixi rather than uv a year ago:

Conda Universe
Able to include CLI tools in environment, e.g. ffmpeg & s5cmd.
Pixi Tasks - alias your common workloads so no-one forget order.
- Might sound lazy, but it helps structure.

The best part? Everyone in the team has been pleased with the transition, and it’s been improvements all around.

Moving on I’d like to share what we’ve really enjoyed when you look back.

Dependent Environments

This is not a pixi-only feature, but it’s great to be able to have multiple environments in our base. We use a mono-repo style of working where we combine everything from Training to Monitoring in the same repo.

We set up a base environment which is shared among the sub-environments, this includes dependencies like polars, deltalake and s5cmd which is integral to our way of working.
Then we extend base with computer_vision and add our CV related dependencies, and for our data_pipeline we extend with data utilities.

What’s great about this? We bump polars in one location and it’ll be validated across all environments at the same time.

What’s also great? We can separate dependencies based on platform, i.e. osx-arm64 will have a separate dependency from linux-64 which is important as osx-arm64 doesn’t have CUDA.

Pixi Tasks

Another featuer we’ve utilized more and more with time is tasks. They’re easy yet powerful.

What type of tasks do we have this far?

pixi run deploy_monitor: deploy our Streamlit App to Snowflake
pixi run labelme: open our labeling program with the correct settings out-of-the-box, and refreshes the pre-signed s3-urls (yes, we’ve patched LabelMe to support URLs :wink:)
pixi run docker_deploy: build our docker containrs and push correctly to AWS based on arguments

With one word: Awesome.
We’ve found it helpful in getting people setup and launching internal tools as there’s no need to remember where script is and what order to run.

Temporary Environments

Both Pixi and UV supports temporary environments and global tools. To test something out run:

Temporary Environments

pixi exec --with <dep> main.py
uv run --with <dep> main.py

Global Tools

pixi global install <dep>
uv tool install <dep>

Final thoughts one year later

Pixi has been a huge success internally in my team, and I’ve been using both pixi and uv privately. Privately I tend to gravitate towards uv as I only have my own environment and it’s a little bit “easier” (hard to explain).

The idea of introducing a completely new tool, pixi, and hearing no complaints, but rather positive remarks is incredible and speaks magnitudes about how good pixi behaves in enterprise settings.
To give some background the team started with broken pip-installs, “works on my computer”, 2 years ago and I transitioned the team into micromamba which stabilized a lot. But it wasn’t a fully positive experience in the team. 1 year ago I moved the team to pixi which has been a lot smoother and happy faces all around.

Happy team, happy life!
~Hampus Londögård

Running Linux on my gaming PC again

Ben Overmyer's Site — Wed, 22 Oct 2025 03:00:00 GMT

With everything that's going on in the world right now, I am increasingly sensitive to the security and privacy implications of the tech I use. While most of my devices are in the Apple ecosystem, there has been one big hole in my device privacy footprint: my gaming PC.

I have been restricted to the Windows ecosystem on my gaming PC because of the games I regularly play. A few months ago, I reluctantly "upgraded" from Windows 10 to Windows 11. This made me anxious at the time, but then it faded into the background as other things took up my mental bandwidth.

Recently, though, Linux came back into my awareness. This past month, KDE celebrated its 29th birthday. This news was all over Hacker News, Mastodon, and some other online social circles I run in. And with Windows 10 formally being sunset, I decided it was probably time to finally switch. Again.

See, I've tried running a Linux desktop before. Generally it works fine. However, two areas have made me stumble hard in the past: design software and games. I've relied on Affinity Suite for the former, which has no Linux version and no plans to have a Linux version. For the latter, I tend to play games that somehow always have game-breaking bugs on Linux, even with Proton.

This time around, I've tried a mixture of the latest developments in Linux and a willingness to change what software I use and what kinds of games I play in order to permanently break from Windows.

So, here's how it's going.

I chose Debian 13 with Plasma and Wayland. Debian is familiar because I've used Ubuntu a lot in the past, but has none of the bloat of the latter distribution. Wayland solves a lot of problems with some games I play, though it does create new problems with some other software. I'm still working through some of those, like Visual Studio Code having bad flickering unless I use a specific set of startup flags.

Incidentally, here're the options I use to fix the flickering for VSCode on Wayland:

code --use-gl=egl --ignore-gpu-blocklist --enable-gpu-rasterization --ozone-platform=wayland

Choosing new software for old problems has been the bigger jump. Instead of Affinity Photo, I'm trying out GIMP. GIMP is way better than it used to be. There's still a big learning curve, so it's an ongoing challenge. For vector work, I'm using Inkscape, which does what I need it to do. For office software, I've already been using LibreOffice on Windows for a long time, so that wasn't a hurdle.

I discovered that Fastmail has a desktop client for Linux. It's pretty new, apparently, but so far it works really well for me.

For games, well, that's been interesting. A lot of games that didn't work well on X11 now work on Wayland. Some don't. The Finals, which is my primary shooter these days, currently has a shader bug that makes it unplayable. It was just introduced, so I don't know when it will get fixed. Monster Train 2, though, works flawlessly. I'm starting to explore new games that are built for Linux specifically, though, which is where things are getting more interesting. I might write a future post just about that.

Spotify works just fine on Linux, but I'm starting to make use of and grow my MP3 library again. I just discovered KDE's JuK for playing music yesterday, and it's surprisingly awesome. That started me down the path of exploring other KDE tools, and I'm discovering a lot to love.

I think this is just the beginning of a paradigm shift in how I use my gaming PC. My Mac Mini and Macbook Pro feel a lot less necessary now, too. Time will tell how this shakes out.

Better Team Building

Dan Stroot — Wed, 22 Oct 2025 03:00:00 GMT

How many of us have experienced team building that left feeling like it was a waste of time and money? If you've had that experience, I have some suggestions.

This post Better Team Building first appeared on Dan Stroot's Blog

Beyond the machine

Nicola Iarocci — Tue, 21 Oct 2025 18:42:17 GMT

I’m just back from reading the transcript of Beyond the Machine, a thoughtful and insightful talk by Frank Chimero.

I’m trying to figure out how to use generative AI as a designer without feeling like shit. I am fascinated with what it can do, impressed and repulsed by what it makes, and distrustful of its owners. I am deeply ambivalent about it all. The believers demand devotion, the critics demand abstinence, and to see AI as just another technology is to be a heretic twice over. Today, I’d like to try to open things up a bit.

Saving democracy for the price of a swimming pool

Open Indie — Tue, 21 Oct 2025 16:14:28 GMT

Claude Skills as Self-Documenting Runbooks/Processes You Share With Your Team

Zachary Proser — Tue, 21 Oct 2025 03:00:00 GMT

This may indeed be a bigger deal than MCP

Gluing & framing a 9000-piece jigsaw

River Writes - A MediaWiki Blog — Mon, 20 Oct 2025 22:13:51 GMT

How I glued Ravensburger’s 9000-piece Dragon Forest puzzle

Intelligence is not intuition

🦉 olshansky 🦁 — Mon, 20 Oct 2025 20:26:53 GMT

AGI is here. AGi is not. No one is talking about it, and it will change everything.

The Road

AltSci Network — Mon, 20 Oct 2025 19:40:48 GMT

An exciting new game I made this past week is now released today! Check out the video here.

The Road by Javantea

I made all the graphics, the songs (3 of them), and the code in 1 week.

A couple of handy KNX gadgets

John Graham-Cumming's blog — Mon, 20 Oct 2025 18:33:15 GMT

KNX is a European standard used in home automation. It's primarily based around a twisted pair bus transporting DC power (30V) and data at 9600 bits/second. Devices attached to this KNX bus draw power for their operation and receive and send messages called telegrams. The devices are typically things like switches, relays, dimmers, HVAC interfaces, small displays, and blind/shutter controllers.

If you're working with a KNX bus you connect a computer to it via bus interface. These are commonly either a USB interface or an Ethernet/WiFi connection. Either way the computer is able to send and receive telegrams and monitor the bus for debugging. This interface is also used for programming the various KNX devices on the bus (for example, associating pressing a button on a particular switch with a particular light circuit going on or off).

Sometimes it's useful to program devices "off the bus" (i.e. away from the actual installation). For this purpose I put together the simplest of minimal KNX buses: a power supply to inject the necessary 30V, a USB bus interface, and a dangling KNX connector (the red and black thing in this photo) that can be plugged into the device to be programmed.

Normally the power supply (on the left) would be wired in permanently, but here I am just using a standard power cord for desktop programming. The USB bus interface is in the middle. There's nothing special about these devices, there are hundreds of KNX manufacturers that interoperate; I just happen to be using an ABB power supply and ABB bus interface.

This works great: plug the device to be programmed into the connector on the right and hook the PC running the KNX programming software ETS into the bus interface via USB. And apart from the two ABB boxes, all that's needed is a power cord, three WAGO 243-211 connectors, and some twisted pair. I used random wires that were lying around, in the real world of KNX installations you'd use proper shielded twisted pair cables!

The other gadget I built is this custom PCB (possibly the world's simplest PCB):

It just connects four KNX terminals together in parallel. The pins at the top are the standard WAGO 243-131 pins compatible with the WAGO 243-211 connector. When soldered together it looks like this:

In conjunction with a bus interface it lets you tap into an existing KNX bus if there's no bus interface present. Or if it's just more convenient to connect where you are working. You simply unplug some device from the bus, plug the bus into this PCB and then plug the device into the dangling connector.

The bus will work normally and you'll have access for debugging and programming. (Note: you can do this because the KNX bus can be a tree and so it's acceptable to plug in a spur of a couple of devices to the main bus line).

The PCB design is based on Matthias Kleine's KNX Distributor; my version can be found here. (If you build this you'll also need Matthias Kleine's footprint library).

If you can’t build it you don’t understand it (122)

Artificial Insights — Mon, 20 Oct 2025 18:14:02 GMT

Further field notes from a centaur

API Pagination: Techniques, Real-World Applications And Best Practices

Engineering At Scale — Mon, 20 Oct 2025 16:05:47 GMT

Learn how X (Twitter) and Spotify use API pagination to handle massive datasets efficiently

Started reading "The Scaling Era: An Oral History ...

Kevin B. Ridgway's Blog — Mon, 20 Oct 2025 14:19:24 GMT

Started reading "The Scaling Era: An Oral History of AI, 2015 - 2025" by Dwarkesh Patel with Gavein Leech.

Dense with citations and definitions. Taking my time here. 😮‍💨

From 6/5/17 in one of my notebooks I wrote down th...

Kevin B. Ridgway's Blog — Mon, 20 Oct 2025 13:53:41 GMT

From 6/5/17 in one of my notebooks I wrote down this quote from Andreesen Horowitz - AI Playbook:

AI is the new relational database, about to get into every important piece of software we write.

This seems to have mostly come true in 2025.

The Bird-Poker Deck

Send More Paramedics — Mon, 20 Oct 2025 11:47:49 GMT

Whereby I talk about a truncated pack of playing cards called the Bird-Poker deck...

tabhisthybrid.sql: Display Oracle hybrid histograms and filter cardinality estimates

Tanel Poder Blog — Mon, 20 Oct 2025 09:05:56 GMT

I have uploaded an early version of my Oracle hybrid histogram examination script that shows you the estimated row-count (cardinality) numbers when looking up a single value with a simple WHERE col = X condition from a table. You can pull the latest tpt-oracle repo or see it here:

https://github.com/tanelpoder/tpt-oracle/blob/master/tabhisthybrid.sql

When troubleshooting optimizer’s row-count estimates on tables with histograms, I sometimes end up gradually simplifying the query or pulling out individual tables and WHERE-clauses to see what estimates the CBO comes up with in isolation.

./project2038: can I keep the Orange Pi Zero running until 2038 and beyond?

./techtipsy — Mon, 20 Oct 2025 06:00:00 GMT

Only one way to find out!

The only Permanent Underclass are the ones who believe it is permanent

swyx's site RSS Feed — Mon, 20 Oct 2025 04:02:22 GMT

From Keyboard to Voice: The Future of Computing Is Talking

Zachary Proser — Mon, 20 Oct 2025 03:00:00 GMT

I just crossed 179 words per minute by talking. Voice-first computing changes how you think, what you build, and where you work.

Interview with a new hosting provider founder

ntietz.com blog - technically a blog — Mon, 20 Oct 2025 03:00:00 GMT

Most of us use infrastructure provided by companies like DigitalOcean and AWS. Some of us choose to work on that infrastructure. And some of us are really built different and choose to build all that infrastructure from scratch.

This post is a real treat for me to bring you. I met Diana through a friend of mine, and I've gotten some peeks behind the curtain as she builds a new hosting provider. So I was thrilled that she agreed to an interview to let me share some of that with you all.

So, here it is: a peek behind the curtain of a new hosting provider, in a very early stage. This is the interview as transcribed (any errors are mine), with a few edits as noted for clarity.

* * *

Nicole: Hi, Diana! Thanks for taking the time to do this. Can you start us off by just telling us a little bit about who you are and what your company does?

Diana: So I'm Diana, I'm trans, gay, AuDHD and I like to create, mainly singing and 3D printing. I also have dreams of being the change I want to see in the world. Since graduating high school, all infrastructure has become a passion for me. Particularly networking and computer infrastructure. From your home internet connection to data centers and everything in between.

This has led me to create Andromeda Industries and the dba Gigabit.Host. Gigabit.Host is a hosting service where the focus is affordable and performant host for individuals, communities, and small businesses.

Let's start out talking about the business a little bit. What made you decide to start a hosting company?

The lack of performance for a ridiculous price. The margins on hosting is ridiculous, it's why the majority of the big tech companies' revenue comes from their cloud offerings. So my thought has been why not take that and use it more constructively. Instead of using the margins to crush competition while making the rich even more wealthy, use those margins for good.

What is the ethos of your company?

To use the net profits from the company to support and build third spaces and other low return/high investment cost ventures. From my perspective, these are the types of ideas that can have the biggest impact on making the world a better place. So this is my way of adopting socialist economic ideas into the systems we currently have and implementing the changes.

How big is the company? Do you have anyone else helping out?

It’s just me for now, though the plan is to make it into a co-op or unionized business. I have friends and supporters of the project, giving feedback and suggesting improvements.

What does your average day-to-day look like?

I go to my day job during the week, and work on the company in my spare time. I have alerts and monitors that warn me when something needs addressing, overall operations are pretty hands off.

You're a founder, and founders have to wear all the hats. How have you managed your work-life balance while starting this?

At this point it’s more about balancing my job, working on the company, and taking care of my cat. It's unfortunately another reason that I started this endeavor, there just aren't spaces I'd rather be than home, outside of a park or hiking. All of my friends are online and most say the same, where would I go?

Hosting businesses can be very capital intensive to start. How do you fund it?

Through my bonuses and stocks currently, also through using more cost effective brands that are still reliable and performant.

What has been the biggest challenge of operating it from a business perspective?

Getting customers. I'm not a huge fan of marketing and have been using word of mouth as the primary method of growing the business.

Okay, my part here then haha. If people want to sign up, how should they do that?

If people are interested in getting service, they can request an invite through this link: https://portal.gigabit.host/invite/request.

What has been the most fun part of running a hosting company?

Getting to actually be hands on with the hardware and making it as performant as possible. It scratches an itch of eking out every last drop of performance. Also not doing it because it's easy, doing it because I thought it would be easy.

What has been the biggest surprise from starting Gigabit.Host?

How both complex and easy it has been at the same time. Also how much I've been learning and growing through starting the company.

What're some of the things you've learned?

It's been learning that wanting it to be perfect isn't realistic, taking the small wins and building upon and continuing to learn as you go. My biggest learning challenge was how to do frontend work with Typescript and styling, the backend code has been easy for me. The frontend used to be my weakness, now it could be better, and as I add new features I can see it continuing to getting better over time.

Now let's talk a little bit about the tech behind the scenes. What does the tech stack look like?

Next.js and Typescript for the front and backend. Temporal is used for provisioning and task automation. Supabase is handling user management Proxmox for the hardware virtualization

How do you actually manage this fleet of VMs? For the customer side we only handle the initial provisioning, then the customer is free to use whatever tool they choose. The provisioning of the VMs is handled using Go and Temporal. For our internal services we use Ansible and automation scripts.

[Nicole: the code running the platform is open source, so you can take a look at how it's done in the repository!]

How do your technical choices and your values as a founder and company work together? They are usually in sync, the biggest struggle has been minimizing cost of hardware. While I would like to use more advanced networking gear, it's currently cost prohibitive.

Which choices might you have made differently? [I would have] gathered more capital before getting started. Though that's me trying to be a perfectionist, when the reality is buy as little as possible and use what you have when able.

This seems like a really hard business to be in since you need reliability out of the gate. How have you approached that?

Since I've been self-funding this endeavor, I've had to forgo high availability for now due to costs. To work around that I've gotten modern hardware for the critical parts of the infrastructure. This so far has enabled us to achieve 90%+ uptime, with the current goal to add redundancy as able to do so.

What have been the biggest technical challenges you've run into?

Power and colocation costs. Colocation is expensive in Seattle. Around 8x the cost of my previous colo in Atlanta, GA. Power has been the second challenge, running modern hardware means higher power requirements. Most data centers outside of hyperscalers are limited to 5 to 10 kW per rack. This limits the hardware and density, thankfully for now it [is] a future struggle.

* * *

Huge thanks to Diana for taking the time out of her very busy for this interview! And thank you to a few friends who helped me prepare for the interview.

Photos from October 20th, 2025

cjlm.ca — Mon, 20 Oct 2025 03:00:00 GMT

Use the saw, fear the saw

Steph Ango — Mon, 20 Oct 2025 03:00:00 GMT

When I learned to use a table saw, my teacher impressed upon me that the machine wants to cut fingers. Fear the saw!

Powerful tools can do powerful things. If you want to make handmade wooden furniture you must cut wood. Your desire to have limbs and your desire to have furniture are not at odds if you learn to use tools safely.

There are table saws that will stop at the touch of a finger, but I don’t know of any chainsaw that won’t cut an arm. There is a limit to how safe a tool can be before its function is crippled.

We should not stop making powerful tools because they are dangerous. Rather, we should empower people to use powerful tools safely.

I use the saw, I fear the saw. I have handmade furniture, and I have all my limbs.

Uppsala Half Marathon done!

Liza Shulyayeva — Mon, 20 Oct 2025 00:01:33 GMT

Around this time last year I came to Uppsala with a friend to check out Rosendal Day - a day organized by the neighborhood I had just bought an apartment in. On the walk to Rosendal from the station I realized it was also the day of the 2024 Uppsala (full and half) Marathon, the runners and spectators gathered on the route through the middle of the city.

Interessant3 #163 | 🏘️Bamako urbanism, 🇫🇷Macron & momentum, 🏅Econ Nobel 2025

Interessant3 — Sun, 19 Oct 2025 23:30:22 GMT

Three Interesting Things for W/C 2025-10-19

Goodbye, for now

Superb Owl — Sun, 19 Oct 2025 22:35:54 GMT

I'm pausing Superb Owl to focus on other things

Once upon a time, Windows looked good

Liam on Linux — Sun, 19 Oct 2025 20:43:54 GMT

No, honest, it did.

Windows 2 was kinda ugly.

https://guidebookgallery.org/screenshots/win203

Windows 3/3.1/3.11 were fine.

https://guidebookgallery.org/screenshots/win30

Muted, boring, but you could look at it all day. And we did.

95 improved it.

https://guidebookgallery.org/screenshots/win95osr2

Tasteful greys, spot colour.

NT 4 improved that a bit more.

https://guidebookgallery.org/screenshots/winnt40

Categorised Start menu, for instance. But nearly identical.

95/NT4 were visibly inspired by NeXTstep, IMHO the most beautiful GUI ever written.

Then it all started to go a bit wrong. The first pebbles bouncing down the mountainside presaging a vast avalanche.

Windows 98.

https://guidebookgallery.org/screenshots/win98

IE4 built in so Microsoft didn't get broken up my the US DOJ. Explorer rendered local content via HTML. Ugly extra toolbars. Some floating, some embedded in the task bar. Ugly gradients and blends in window title bars.

Cheap and plastic and tacky.

But that is around the time that media and gaming PCs went mainstream, home internet use (often over dialup) went mainstream, and the alternatives died out (Amiga, ST & GEM, Arm & RISC OS) or very nearly died (classic MacOS, NeXT merger, Rhapsody).

So it's what many saw first and loved and remembered.

Result, people write entire new OSes designed in affectionate homage:

https://serenityos.org/

Look at the toolbars. Look at the textures in the title bars. This isn't Win9x, this is specifically Win98.

https://www.digibarn.com/collections/screenshots/KDE%201-x/i...

Specifically:

https://www.digibarn.com/collections/screenshots/KDE%201-x/h...

<- textured title bars

https://www.digibarn.com/collections/screenshots/KDE%201-x/t...

<- gradients in title bars

https://www.digibarn.com/collections/screenshots/KDE%201-x/m...

<- Windows-style colour schemes

KDE started out as a reproduction of Windows 98/98SE by a team who didn't realise that what they were looking at was WordPerfect 5.x instead of WordPerfect 4.x -- as the late great Guy Kewney put it:

"WordPerfect 4.2 was a bicycle. A great bicycle. Everyone agreed it was a great bicycle, just about the best. So what Wordperfect did was, they put together a committee, looked at the market, and said: 'what we'll do is, we'll put 11 more wheels on it'."

Win98 is Win95 festooned with pointless needless Internet widgetry because the DOJ was about to split MS into separate apps and OS companies, because MS drove Netscape into bankruptcy by bundling IE free of charge with Windows.

Strip all that junk off and what's left underneath is a better UI. But the German kids writing their "Kool Desktop Environment" didn't realise.

After that came WinME and Windows 2000, which turned down the bling a bit as the lawsuit was over, but it was only a blip.

Then came XP with its "Fischer-Price" themes.

Then Vista with gratuitous transparency everywhere because GDI.EXE had been ripped out and replaced with a compositor and that's no fun if you don't use some 3D features like see-through stuff.

Then 7 toned that down a bit and everyone love it.

Then the universally detested Win8, and then that was toned down and the Start menu put back for Win10, which is roughly what UKUI and Deepin copied in China, or Wubuntu in the West.

Then Win11, as copied by AnduinOS and a few others, which for this long-term Windows user is the worst release ever. I can't even have a vertical taskbar any more. It's abhorrent.

(Content repurposed from here:

https://news.ycombinator.com/item?id=45626910

Inspired by this:

https://blogsystem5.substack.com/p/the-ides-we-had-30-years-ago-and )

comments

Skepticism, Early Trends & an Early Leader in AI-for-Hedge Funds Race

Magis — Sun, 19 Oct 2025 17:02:47 GMT

Ken Griffin, founder of Citadel, is skeptical of AI’s stock-picking abilities. AlphaSense, meanwhile, says AI is driving revenue. This post maps the early product categories forming in the space.

Missing arkaine already

hlfshell — Sun, 19 Oct 2025 09:44:09 GMT

Recently I took on a contract job to fill the coffers a bit while HiredCoach handles its initial launch. Nothing that I can talk that much about publicly, but I can reveal that it’s your typical AI office assistant for a particular business process. As specific as it is exciting a description, I’m sure. Given that I recently wrote an entire article about the highs and lows of my custom framework, arkaine - and within I mention that I lkely won’t continue developemnt on that particular implementation of those ideas I wouldn’t exactly want to pull it out for a client hoping for their PoC to be easily maintainable for future developers as they pursue it; it’s too esoteric a framework and oto tied to my own development preferences.

Emacs time-zones

xenodium.com @alvaro — Sun, 19 Oct 2025 03:00:00 GMT

Emacs ships with a perfectly functional world clock, available via M-x world-clock. Having said that, there are two things I wish it had:

A quick way to interactively add any city (bonus points for fuzzy search).
An easy way to shift the time back and forth.

As far as I can tell, these are neither available nor possible on the built-in world-clock (please correct me if otherwise), so when my friend across the world recently asked me for the best time to meet, I knew this was the last nudge I needed to get this done.

With that, I give you M-x time-zones (now on GitHub).

There isn't much to talk about other than time-zones accomplishes the above tasks very easily without resorting to writing elisp nor accessing via customize, which I seldom use.

As I mentioned, time-zones is on GitHub if you'd like to give it a spin. It's super fresh, so please report any issues. Hope you like it.

Make it all sustainable

Reckon time-zones will be useful to you? Enjoying this blog or my projects? I am an indie dev. Help make it sustainable by ✨sponsoring✨

Need a blog? I can help with that. Maybe buy my iOS apps too ;)

Why Use AI CLIs When GUIs Exist?

Tiberriver256 — Sun, 19 Oct 2025 03:00:00 GMT

People keep asking me why they’d ever use an AI command-line tool when the GUI works fine. The answer: CLIs let you mix deterministic scripting with non-deterministic AI judgment calls.

Pure AI is hard to steer. Pure scripting breaks on edge cases. CLI tools blend both.

The Difference in Action

Here’s the example I show:

copilot -p "Write me three reports on Bob, Dave, and Larry"

versus

"Bob", "Dave", "Larry" | foreach { copilot -p "Write me a report on $_" }

The first is an AI call that might handle all three names or might not. The second is three separate calls with a guaranteed structure. You control the iteration. The AI handles the content.

Why GUIs Can’t Compose Like This

GUIs excel at one-off tasks and visual feedback. But they can’t compose operations the way CLI tools can. You can’t pipe a GUI through a loop. You can’t redirect its output to another tool. You can’t script around it when you need deterministic control flow with non-deterministic content generation.

The command line gives you programmable interfaces to AI. That’s the difference.

Why Use AI CLIs When GUIs Exist? was originally published by Micah Rairdon at Tiberriver256 on October 19, 2025.

Photos from October 19th, 2025

cjlm.ca — Sun, 19 Oct 2025 03:00:00 GMT

The UUID collection

Built on Shards of Silicon: Robert Alexander's Tech Blog — Sun, 19 Oct 2025 03:00:00 GMT

Publishing my first collection of blog posts

Why UUIDs won't protect your secrets

Built on Shards of Silicon: Robert Alexander's Tech Blog — Sun, 19 Oct 2025 03:00:00 GMT

UUIDs and Indirect Object Reference

The Accountability Problem

James Shore — Sun, 19 Oct 2025 01:21:01 GMT

This is a transcript of my keynote presentation at the Agile Cambridge conference in England on October 2nd, 2025. The topic was “The Accountability Problem.” How do we define software department accountability so our business partners don’t do it for us?

Introduction

The Accountability Problem

Demonstrating Accountability

Quantifying the Bet

The First Two Years

Conclusion

Thanks for having me. I’m very happy to be here in Cambridge. This is my first time visiting, so I spent the afternoon Tuesday doing some sightseeing, including a lovely ride down the River Cam. I was delighted to learn yesterday that I had Simon Wardley to thank for chauffered punt rides, including the completely fictional story I was told about the mathematical bridge.

One of the things I love about Cambridge is its rich history. Of course, lots of history is important when you have...

...this monster eating up every second.

That’s the Chronophage outside of Corpus Christi college, if you aren’t familiar with it, and much more impressive in person than in my terrible vertical picture with window glare.

Before we get going, I should explain my context. You’ll hear a lot of advice at this conference, and how much that advice is relevant to you has a lot to do with how much their context matches yours.

I’m currently VP of Engineering at OpenSesame, and for the 23 years prior to that, I was a consultant. As VP, and as a consultant, I specialize in late-stage startups: entrepreneurial organizations that were successful enough that they were able to grow. These are companies with a product mindset that value entrepreneurial thinking, but they’re also trying to grow up and be “real companies,” and they’re trying to figure out how to do that without losing their entrepreneurial edge.

So that’s the context of my material: entrepreneurial companies building software products that they sell. If you’re not in that situation, I encourage you to mine my talk for ideas, but don’t try to apply it blindly. And if you are in that situation... well, mine my talk for ideas, and don’t try to apply it blindly!

A few more disclaimers. All the substantive content of this talk—the words, diagrams, examples, and so forth—were created with my actual meat brain, without any AI. Large images have been sourced from various locations, and are credited in the bottom left corner.

I’ve also dressed up some of the slides with decorative AI-generated images from ChatGPT 5, like that rapper holding a stop sign. If there’s one thing GenAI is good at, it’s embellishment.

I should also mention that, although I work for OpenSesame, I’m not speaking for OpenSesame. I created this talk on my own time, and I’m technically on vacation right now. The opinions I express are my own.

Anyway, as I was saying, one of the things I love about Cambridge is its rich history. I’m sure you’ve all heard several times by now that the university was founded back in 1209, by people fleeing [waves hand dismissively] the other university. In comparison, my home town of Astoria, Oregon, which is the oldest permanent settlement on the west coast of the US, was founded in 1811. I think that’s last Tuesday by British standards.

Part of the history surrounding Cambridge is this man: LP Hartley. He was born in Cambridgeshire in 1895, although he never went to Cambridge University. He went to... the other one. But, despite that choice, he went on to become a successful novelist.

His most famous novel is “The Go-Between.” It begins with a wonderful opening line:

“The past is a foreign country: they do things differently there.”

And that connects us back to Cambridge. The University of Cambridge Press published this book in 1985. It’s by David Lowenthal, and it created an entire sub-genre of history called Heritage Studies. It’s still in print today, in a revised edition.

The concept of this idea is that, although the past informs the present, the present also informs the past. Our thoughts and actions today extend from events that occurred in the past. But, at the same time, our understanding of the past is colored by our thoughts and actions today.

The past is a foreign country. They do things different there. But we can’t visit the past. We can’t see what they did differently. We can only interpret what they’ve left behind.

And like medieval scholars drawing elephants they’ve never seen, we make those interpretations through the lens of our own biases.

I love these medieval drawings of elephants. They’re so delightfully strange.

But I’m not showing you these pictures to make a point about how difficult it is to draw an elephant when you haven’t seen one.

If you go back to Corpus Christi, where they have the Chronophage—not right now! I’ll start talking about software soon, promise. Anyway, at Corpus Christi, they have Matthew Paris’ Chronica Majora. It contains this drawing of an elephant. You might assume that it came much later, because it’s so much more accurate. But all of these drawings were created around the same time, in the 13th century.

It’s quite the difference, isn’t it?

I’m not showing you these images to make a point about medieval monks. I’m actually showing them to make a point about your biases. In the modern era, we expect images to be true to life. We have cameras that give us nearly perfect representations of the world. But realism isn’t what medieval monks were always trying to accomplish. Religion and metaphor were a central part of their lives, to a degree that I think we in the modern world have trouble understanding.

The elephants on the left aren’t really elephants. They’re a way of presenting a moral lesson about your place in the world. The image serves that story. It’s not there to teach you about elephants. It’s there to teach you about God.

So if your first reaction to these elephants was to laugh at those ignorant medieval monks... then perhaps you’ve fallen prey to your biases. The elephant doesn’t look like an elephant because the metaphor was more important than the reality.

The past is a foreign country. They do things differently there.

[beat]

The past informs the present, but the present informs the past. We can’t help but to interpret it through the lens of our own experience, and those biases distort the reality of what it was actually like to live there.

This idea fascinates me, because it’s not only true of the past; it’s true of everything. Our biases and experiences influence so much of how we interpret the world.

I taught teams Extreme Programming for a few decades, as a consultant. Now that I’m VP of Engineering, I’m still teaching it, in a way. One thing that’s stood out to me over the years is that the people who struggle the most to learn XP are the ones who are more senior.

Junior developers have no problem! It’s the senior developers who struggle. They have too much baggage from their preconceptions.

A good example of this comes from Microsoft. XP was popular in the early 2000s, and practices like test-driven development, which come from XP, were entering the mainstream. So Microsoft published a set of “Guidelines for Test-Driven Development.”

There was a big backlash, and Microsoft took their guidelines down pretty quickly, because they got them terribly, ridiculously, horribly wrong. Microsoft didn’t actually practice XP, as far as I can tell, so they didn’t know that XP is a way of keeping software design simple and evolving it in response to customer needs. In XP, you don’t create your design in advance; you discover it as you go, and you focus on keeping it as simple as you can.

People who have practiced XP know that TDD is about tests and code evolving in step with each other, so that you learn as you go. A few lines of test code. See the tests fail. A few lines of production code. See the tests pass. A few improvements to the design. See the tests pass. A few more lines of test code. See the tests fail. And so on, and so forth, until the software is done, without following a preconceived path.

As with many companies past and present, the Microsoft way wasn’t to evolve their design; it was to come up with a software design in advance, then build to that preconceived design. And so they saw what Kent Beck and others had said about TDD and interpreted it in the only way they knew how: as a way of coming up with a software design in advance, and then building to that design. Their guidelines for TDD were to:

Gather the requirements for your new feature
Make a list of tests that will satisfy the requirements
File work items for the tests that need to be written
Generate all the interfaces and classes you’ll need—using Visual Studio, of course!
Write all the tests
Write all the production code

I’m not exaggerating! This is what they actually said. Refactoring, iteration, learning as you go—key ideas of XP and TDD—nowhere to be found.

Microsoft’s approach to TDD was the exact opposite of what TDD was about. But they were only able to interpret TDD through the lens of their corporate approach to software development. And to this day, you see this same misunderstanding about TDD repeated by people who are steeped in up-front thinking.

XP is a foreign country. We do things differently here.

[beat]

As people, we can’t help but to interpret the world through lens of our own biases. But that means that we make assumptions about the world that aren’t true, and we can’t even recognize that we’re doing it. It’s not just the past that’s a foreign country... almost everything is.

That leads to problems. And in software, one of the biggest, is...

...the Accountability Problem.

[beat]

People who aren’t software developers have probably seen more “programming” in movies and TV shows than in real life. Those shows are filled with magical people who can “hack” anything off-camera and in moments.

“The ship’s going to ram us, captain!” “Quick, hack into their retro-encabulator and reverse the polarity of their thrusters!” (frantic typing, dramatic music, camera zoooooooom) “It just barely missed us! Hoorah!”

I only wish software development was that cool.

Of course, people do know that’s fiction. Some of them might have even written code in school. But in school, people write small programs that fulfill an assignment and don’t have to be maintained.

Or maybe they’ve vibe-coded an app using GenAI.

None of these experiences bear any relationship to the modern world of software development.

TV show hackers are just another deus ex machina... quite literally. It’s lazy writing.

School projects don’t require long-term maintenance or large-scale coordination.

Unsupervised AI coding assistants feel magical, but they break down once you get past the prototype stage.

All of these things trick people into thinking that software development is about code. About hands on keyboard. But that’s not what it’s about at all.

To paraphrase Kent Beck, professional software development is about...

Communication and collaboration between large numbers of people with different perspectives.

Feedback loops that enable us to tell when we’re building the right thing, and the thing right... and when we’re not.

Simplicity, because it’s our ability to understand and change software that determines timelines and cost.

Courage to do the right thing even when it’s hard, and it’s often hard.

Respect for the people doing the work and the people affected by the work.

We know that software development is a matter of discovery and coordination. But to our business partners, we’re a foreign country. They can only see us through the lens of their experience.

Their experience is that software development is about writing code, in the same manner that someone might do a homework assignment. It’s tedious, perhaps; time-consuming, maybe; but ultimately, a matter of buckling down and doing the assignment... following a straight path from here to there.

If you think this way—if you think that software development is like a big homework assignment—then you start making a bunch of assumptions.

You assume that you only need to define the assignment correctly to get the right answer.

You assume that the assignment has one right answer, and there’s a clear path to that answer.

You assume that people can tell you what that path is and how long it will take.

You assume that, when work isn’t getting done according to that schedule, it’s because people aren’t working hard enough.

And you assume that, when work’s behind, putting pressure on people will make them work harder and get it done on time.

Ultimately, you think software development looks like this [play animation]: a trip from point A to point B.

When in reality, it’s more like this [play animation]: a process of exploration and discovery, where the outcome isn’t known until you get there.

Software development is a foreign country. We do things differently here.

These misconceptions aren’t harmless. They extend deep into organizational structures. The biggest impact is how software development is run in most organizations. Most organizations use project-based governance. You create a plan, then you work the plan. If you execute the plan properly, you’ll be successful, and you’ll finish on time.

In this environment, it’s management’s job to make sure that the plan is created correctly, worked correctly, and that people don’t slack off.

How do you know management is doing their job? What are they accountable for?

Delivering software on time and on budget.

It’s clean, it’s neat, it’s easy to understand, and it matches people’s misconceptions about software development.

And it results in bad software.

The whole premise that we can define the assignment in advance is incorrect. Software development is a process of discovery—of iteration and refinement. We learn as we go, and that changes our plans.

This is an Agile development conference. You’ve heard it all before. I’m not going to belabor the point.

But our business partners haven’t heard it before, or if they have, it’s counter to their experiences. Like us seeing medieval pictures of elephants, like Microsoft with TDD, they can’t help but interpret the world through their own biases. And those biases lead to project-based governance.

In their minds, anything less... is a lack of accountability.

So what can we do about this?

Ultimately, accountability is about being responsible for a set of results. At the executive level, everybody has to be accountable.

Marketing is responsible for generating leads for your Sales department. They say how many qualifying leads they’re going to create, and they’re accountable for having done so.

Partners also generates leads, or even sales, from people who are using complementary products and services. They’re accountable for bringing in partners, and for the revenue those partners generate.

Sales converts leads into paying customers. They’re accountable for the revenue generated by those customers.

Customer Success takes care of your customers. They’re accountable for retention, and for generating additional revenue from upsells.

Everyone is accountable for doing what they say they’ll do, including us in software development. But there’s something different about how everyone else is accountable. Did you notice?

For other departments, accountability is about the results they’re bringing to the organization, not the work they’re putting in. Sales isn’t saying, “we’re going to land customer X on date Y.” Everybody knows that sales take time, and things go sideways. So Sales says “we don’t know exactly which customers we’re going to land, or when, but overall, we’re going to generate X dollars of revenue.” Same for Marketing, and Partners, and Customer Success. We in software are the only ones who have to predict exactly what and when.

Our business colleagues aren’t unreasonable. They understand that things go wrong. But they also believe, deep in their hearts, that if you aren’t accountable, you won’t put forth your full effort.

And if we don’t define how we’re going to be accountable, they’ll do it for us, in the only way they know how. Which features are you going to deliver? When? If you don’t deliver them on time, you aren’t being accountable.

We have to change the script.

So what should we be accountable for instead? What, exactly, do we do? What results do we create?

[beat]

We create new opportunities. Let’s say that the trajectory of your company is to grow its annual revenue by $10mm per year. Our job is to increase that rate of growth, to $12, $15, $20mm per year. Every time we ship a new feature, we should be increasing that rate of growth.

Our features should open up new markets, allowing Marketing to generate more leads.

We should provide useful APIs, allowing Partners to build new relationships.

We should respond to market trends, allowing Sales to convert more leads.

And we should fix the problems that get in customers’ way, reducing churn and increasing upsell.

What are we accountable for? We’re accountable for improving our companies’ trajectories. Every dollar invested into software development, other than keeping the lights on, should be reflected in permanent improvements to the value your company creates. That value may not be literal dollars or pounds; it may be helping to cure malaria or fighting climate change. But however you define value, the purpose of our work is to change that trajectory for the better.

It’s easy to say that we’ll be accountable for improving our companies’ trajectories. But how do we actually demonstrate that we’re doing so?

It’s nearly impossible to quantify the impact of any individual feature. It takes months to see an impact from a new feature, and even then, we can’t say that feature X resulted in change in behavior Y. Let’s say churn went down by half a percent. That’s great! Did it go down because of the feature we just released? Or because of a different one? Or is it more that interest rates just dropped and we hired an amazing new director for our customer success department?

This is why it’s tempting to look at when you’ll deliver a feature. It’s easy to measure.

But ultimately, features are a means to an end, not the end itself. There’s an old cliché that people don’t want a shovel, they want a hole in the ground. And they don’t want a hole in the ground, they want a building foundation. And they don’t want a building foundation, they want a nice big stable. And they don’t want a stable, they want war elephants that make their enemies say things like, “Carthago Delende Est!”

When we talk about delivering features, we’re talking about shovels when we should be talking about striking fear into the hearts of Roman soldiers.

So instead of talking about features, I’ve introduced a way of talking about value. At OpenSesame, we’re calling them “Product Bets.”

Before we go further, a quick disclaimer. The term “bet” is common among startups and other entrepreneurial organizations, so you’ll hear the phrase “product bet” from a lot of different people. Each of us is using it in our own way. So my use of “product bets” isn’t the same as what you might have seen from somewhere else.

Okay, so what do we mean when we say product bet?

Ultimately, it’s a strategic investment in a business result. It’s summarized with a single sentence that has two parts:

First, the business outcome: Strike fear into the hearts of Roman infantry!

Second, the means by which we do so: ...by fielding a battalion of war-capable elephants.

The result always comes first: strike fear. The mechanism comes second: war elephants. And even then, it’s high level. We need a stable, we need animal breeders and trainers, we need to train soldiers, we need a supply line. We need so many things, and not just software. Those are features. We don’t talk about features in our product bet. We keep it high level. Just the headline.

Next, we need a sponsor. Who amongst our leadership team is going advocate for this result? At OpenSesame, it’s usually our Chief Product Officer. But sometimes it’s our Chief Customer Officer, who’s in charge of sales and retention.

For the Carthaginians, of course, the sponsor is General Hannibal.

Next we talk about estimated present value. This is a core innovation. As I said, it’s nearly impossible to measure the impact of any feature, or even set of features. There’s too many confounding factors.

So we don’t measure the impact. We estimate the impact.

My software department takes accountability for delivering estimated value, not measured value.

Now, that’s not to say that we don’t want to validate results. Jeff Patton talks about using Dave McClure’s Pirate Metrics to do so. I welcome and encourage that kind of validation. Ultimately, you have to decide if the bet was successful.

(Spoilers: Hannibal’s bet isn’t going to be as successful as he was hoping.)

But the key idea of these product bets is that you don’t have to measure value. You only have to decide if the bet was successful. If it is, we get credit for the estimated value, not the actual value, which saves us a lot of time and trouble.

Estimating value allows us to be accountable without predicting specific dates and features.

Remember that the head of Sales is accountable for delivering a certain amount of new business every year. Let’s say it’s 10 million dollars. They’re going to deploy a certain number of sales people towards small-to-medium businesses, some towards mid-market, some towards enterprise. They’re going to conduct training and organize incentive programs. They’re going to get everybody fired up about how they need to sell, sell, sell! They’re going to monitor calls, check SalesForce, make sure people are following up.

But they’re not going to say, “Enterprise X is going to sign on date Y.” Because they can’t. The buyer’s going to go on vacation. Legal’s going to demand redlines. A year in advance, nobody knows when the contract will be signed, or if it will even be signed at all. But overall, they’ve got enough going on that they can say, “yes, we’re going to close $10mm in sales this year.”

The same is true of us. A year in advance, we don’t know which bets we’re going to do. We don’t know how much it’s going to cost to build them. We don’t know which ones are going to be successful and which ones are going to fail. But overall, we can say, “Yes, we’re going to deliver bets that are worth $10mm in estimated value this year.”

And that’s accountability.

[beat]

Wait a moment. “We don’t know how much it’s going to cost to build a bet?” How can we decide what to do if we don’t know how much it’s going to cost?

At this point, all we have is a headline. There’s no way for us to know how much it will cost, because we don’t know exactly what we’re going to build.

And if we’re doing Agile right, we will never know exactly what we’re going to build until after it’s done. As you all know, Agile software development is iterative and incremental. It’s a process of discovery.

I like Eric Ries’ characterization of this idea: we build, we measure, we learn, over and over again. And we don’t know what we’re going to do here [points at “build” step] until we know what happened here [points at “learn” step]. As long as we’re genuinely learning, we can’t know our costs in advance.

What we can do, though, is put a maximum limit on how much we’ll spend. I call it the “maximum wager,” to continue with the betting theme. We track our spending, and if we’re not successful by the time we hit the limit, the bet has failed. We shut it down and move on to the next one. Or, at the very least, take a hard look at where things are at and decide on a new wager. As long as the total spending is less than the present value, it could still be a good investment.

The amount of the maximum wager is for your leadership team to decide. It’s not an estimate of cost. It’s a gut check about risk and value. The higher the value of the bet, the more you can wager. But you don’t want to wager so much that it would be crippling if the bet failed. Some bets will fail, and you’ll get nothing for your efforts. Success doesn’t mean fielding elephants. Success means winning a war with our elephants, and those Romans can be tricky.

The maximum wager is based on your leadership team’s gut feel of the risk and value involved. It’s not based on how much we think the bet will cost; it’s based on how much we’re willing to lose.

And then we do our best to make sure that potential loss is minimized. We use the "Build, Measure, Learn" loop to validate whether the bet is going to be successful early on. Maybe one loop is focused on taking elephants up into the mountains to see how they handle the harsh conditions, and another loop dedicates a “red team” to see if they can be spooked into fleeing during battle.

It turns out they can. It would be nice to discover that early, not in the middle of battle with the Romans.

Although we in software are accountable for estimated value, not actual value, we only get to take credit for successful bets. It’s in our interest, and everyone’s interest, to weed out the unsuccessful bets early, so we can spend more time focusing on the successful ones. And so, we should design our build-measure-learn loops to test for failure as early as possible.

With value and a maximum cost, we can perform an apples-to-apples comparison between bets and choose the one that seems like the best one to do next. Often, that will be the one with the highest value.

But don’t be fooled by all these numbers! They’re just estimates and guesses. A smart leadership team will go with their gut, not just follow the numbers like robots. The numbers are there to feed a conversation: to get people thinking. They’re not there to substitute for experience and judgment.

The big question: Does this work?

For me, so far, yes. It took me nearly two years to get my leadership team to really engage with this approach, and I needed the strong support of my CEO and CPO to get there. My CEO, in particular, had to get pretty insistent before people would engage.

The fact is, putting together bets, even such high-level ones, takes work. It also makes people accountable, by putting concrete numbers on previously-vague statements about value, and despite everybody’s desire for other people to be accountable, most leadership teams I’ve worked with aren’t really looking to take on more accountability themselves.

But, thanks to my CPO and CEO’s support, I can say that we are building software using product bets. We identified a handful to take to the leadership team earlier this year. They estimated the value, then chose a specific set of bets for us to pursue based on our capacity. It’s definitely elevated our conversation around product strategy, and I can see it getting even better as we gain familiarity with the approach.

What we haven’t done yet is finish any bets. We just started our first formal bets this year. So I can’t yet tell you how it will turn out.

What I can tell you is that I’m getting a lot less pushback than I used to about features and dates. The conversation is focused on bets, not features and dates, and when we talk about what folks want from Engineering, it’s less about, "tell me when you’re going to be done," and more about how we can take on more bets.

So, even though I haven’t yet used product bets to truly demonstrate accountability, they already seem to be helping.

Does it work? For me, so far, yes.

To summarize, we’re working on demonstrating accountability with product bets.

Specifically, we’re going to commit to delivering a certain amount of estimated value each year.

That estimated value comes from product bets. Each product bet is summarized by headline that focuses on a business result with a high level description of how we’ll achieve that result.

The bets to pursue are decided by the leadership team, and each bet has a leadership sponsor who champions it within that team.

Bets have an estimated value, and we focus on the estimate rather than trying to prove out actual value.

The leadership team also defines a maximum wager for each bet, which is based on a gut feel of risk and benefits, not costs, and together with the present value allows us to perform apples-to-apples comparisons of the bets.

At this point, you might be wondering: where does that "present value" number come from?

The answer, like all things in business, is spreadsheets. Magical spreadsheets filled with arbitrary guesses.

The secret to spreadsheets is that they make our guesses look official. Professional. Good Business-y.

But seriously, yeah, spreadsheets. Let me show you.

Let me start out by explaining what “present value” is, just in case some of you aren’t familiar with it.

The core idea of “present value” is that money—let’s say $10—is worth more today than it is tomorrow. Today, I can buy a couple of candy bars with $10. In a few decades, I’ll only be able to buy half a candy bar due to inflation.

This is called “the time value of money,” but it’s very simple: money today is worth more than money tomorrow.

What this means is that earning $10 today is better than earning $10 next year, and even better still than earning $10 in two years. If inflation was 20%, $10 in future value next year would be equivalent to $8.33 in present value today. $10 in future value two years from now would be equivalent to $6.94 today. And so forth.

Of course, inflation isn’t 20%, thank goodness. But when your company makes an investment, they expect a certain return on that investment. The return they expect is called “cost of capital.” Your leadership team will tell you the cost of capital to use. It’s based on their judgment of how much they could get from using the money on other investments along with an adjustment for risk. For these examples, I’m arbitrarily choosing a 20% cost of capital.

The neat thing about cost of capital is that you can wager your entire present value and still get a good return on investment. As long as the bet is successful, even if you spend all of the present value, you’re still making money.

If you ask me for an investment and promise to return $10 to me today, $10 next year, and so on for the next three years, you’ll return $40 total. If my cost of capital is 20%, then I can look at the present value of each of those returns. It’s $10 today, $8.33 next year, $6.94 the following year, and so forth. Adding up those future returns gives me the total present value, which is $31.06, which means that I can invest up to $31.06 and still get at least a 20% return on my investment.

Okay, so that’s what present value is. Now, how do we determine what numbers to use?

As I said before—spreadsheets and guesses. You build a financial model that makes guesses about the future.

I’m going to share the model I used, but I have to be honest: I had a lot of trouble getting my leadership team to engage with product bets at first. In order to get this off the ground, I had to provide the financial model myself... and honestly, I think it could be a lot better.

We have a new CFO at OpenSesame, so I showed him about the model I’m about to show you. He said—this is a direct quote—“it’s an okay framework to start.” He also said, “come talk to me early when you start on the next set of bets.”

So, yeah. Thank you for coming to my okay talk. I’m sure it will be better next year.

In all seriousness, our CFO liked the general idea of product bets, and the categories I was using. He just thinks he can make the specifics more rigorous, which is great, and I’m looking forward to his help.

The fact is, it doesn’t really matter if the model is accurate or not. The important thing is to get people to engage with value rather than cost and dates being the primary driver of decision-making. You can use a rough, back-of-the-envelope model to get started. That’s what I did. As long as you’re consistent with your approach across bets, it’s still useful.

With that said, our product bets are broken down into five sections. Each one has its own little present value calculation.

There’s Sales, which represents the money we make from new customers as a result of the bet.

Upsell, which is the money we make from existing customers as a result of the bet.

Retention, which has to do with the fact that we sell subscriptions. Once we make a sale, we keep making money from that customer every year, so long as we can retain them. This is typical in the modern software-as-a-service world. So retention is a very important number.

Cost savings is reduction in spending, which counts as value, because spending $5 less on candy each year means I have $5 more in my pocket.

And then expenditures, which is additional spending we’ll incur as a consequence of the bet. For example, maybe I spend $5 less on candy each year, but I have to spend $1 every year on a budget tracking app that reminds me not to waste money on candy.

To illustrate these ideas, let me introduce you to my new employer: War Elephants as a Service.

We’re your one stop shop for all elephant-related warfare. We take care of the elephants, so you can take care of the invasion! Look at our glowing testimonials from top customers: Carthage... and Rome! Business is good. Or at least, it was. There’s not much demand for war elephants these days.

PS: Apologies for the mutant two-trunked elephant in the logo. Our ex-CEO tried to solve our financial problems with cost-cutting, so he replaced all of our graphic designers with AI. His last words as he was escorted out the building were, “I’ve made a terrible mistake.”

But we have new CEO now! Babar is our new “Chief Elephant Officer,” and he has an idea for keeping our business relevant in today’s fast-paced world. Since nobody seems to want war elephants any more, we’re going to switch from “war elephants” to “more elephants!” Elephant parades! Elephant-themed merchandise! And especially, cute baby elephants! Nothing says “more elephants” like an adorable fuzzy pachyderm.

Specifically, we’re going to open up new markets and improve retention by introducing family-friendly elephant activities. That’s our bet.

To quantify this bet, we’re going to look at the five categories I mentioned before: Sales to new customers, upsells to existing customers, retention, cost savings, and expenditures.

[points to “Service Obtainable Market” row] For new sales, we’re going to look at the “service obtainable market,” which is the total size of the market that we can reach for family-friendly elephant activities. Let’s say it’s 100 million dollars at the end of the first year, and grows over time as word gets out.

[points to “Sales Rate” row] Next, we’re going to estimate how much of that market we can capture. We face competition from zoos, but nobody has quite the expertise deploying large numbers of elephants that we do, so we’re going to say we can sell into 1% of the market, and that will also grow over time.

[points to “Future Value” row] Multiplying the service obtainable market by our sales rate of 1% gives us the amount we expect to make each year in future dollars. [points to “Present Value” row] Then we apply our present value formula at a 20% cost of capital and [points to “Total Present Value”] add it all up to get a total present value of nearly $5 million from new sales.

It all looks very official, doesn’t it? But how do we know it’s a 100 million dollar market? How do we know we can sell into 1% of it?

We don’t! It’s guesses. Educated guesses, maybe, but ultimately... guesses. That’s how these things work, and that’s why you need your leadership team to get involved. You can make your models more and more rigorous, but at the end of the day, somebody’s making their best guess, and those guesses should be overseen by the people in charge of those departments.

Next, we look at upsell. How many of our existing customers can we convince to try our new family-friendly elephant activities?

[points to “Service Obtainable Market” row] As before, we start with the total market that we can reasonably reach. This is the amount we think that our existing customers would be willing to spend on our new offering. In our case, it turns out our customers aren’t actually using their war elephants for war, but for things like parades. We think there’s a good $25 million to be made from our existing customers, and we don’t expect that to change much over time. To be clear, that’s not what we make from our existing customers, it’s the extra amount we think they’d pay for our new service.

[points to “Sales Rate” row] Then we look at our sales rate for that market. Given that our customers are already using their elephants for parades, we think they’re going to be pretty receptive to us providing services to support them. We estimate that we’ll be able to convert 5% of the upsell market, and that number will also grow over time.

[points to “Total Present Value”] Multiply the numbers, apply present value formula, and we have the total upsell value of $6.3mm.

Now let’s talk about retention. Our retention numbers have been pretty bad—as I said, countries don’t really need war elephants any more. [points to “Service Obtainable Market” row] But we still have a hundreds of millions of recurring revenue, even though it’s going down each year. That’s the ARR line—annual recurring revenue.

[points to “Retention Change” row] By pivoting from a focus on war to a focus on the military parades our clients are actually using elephants for, we think we can stem the bleeding a bit. Not much... about a quarter of a percent each year, going up slightly over time.

[points to “Total Present Value”] Multiply, present value, and there you have it. Three and a half million.

What about cost savings? [points to “Work Eliminated” row] Is this bet going to eliminate any of the existing work our employees do? Not really. [points to “Expenses Eliminated” row] Is it going to eliminate any expensive software subscriptions or other expenses? No, probably not.

[points to “Total Present Value”] Normally, we’d add up the cost savings and apply the present value calculation, but the numbers total out to zero in this case.

And finally, expenditures. How much more are we going to spend as a result of this bet?

Well, there’s the cost of developing the bet itself, which is our wager, but we’ll bring that in later. In this section, we’re looking at the ongoing costs of running the program. [points to “Future Value” row] I’m going to hand-wave that a bit—you might have multiple line items here normally—but let’s just say it’s $2mm per year, going up as the program becomes more popular. Elephants aren’t cheap.

[points to “Total Present Value”] Present value, etc., gives us a total of $8.5mm in expenditures.

Bringing it all together, we have $5mm in new sales, $6.3mm in upsell, $3.5mm in improved retention, $0 in cost savings, and $8.5mm in expenditures. That comes to a total present value of $6.3mm before our development costs.

Now, how much do we want to wager on development? The leadership team thinks this is a slam dunk, and a way to save the business, so they’re going to wager nearly all of the value. Five million dollars. Remember, using cost of capital to determine present value means that we could wager the entire present value and still come out ahead... if the bet is successful.

That said, bets still have a risk of failure. Our leadership team is making some assumptions about how much people will be excited about baby elephants, so we’ll want to work incrementally and iteratively to test their assumptions early.

To summarize, the present value of the bet is based on sales to new customers, upsell to existing customers, change in retention, cost savings, and non-development expenditures related to those benefits.

And that’s how we come up with the numbers in the product bet. To bring it back around, we’re betting that we can open up new markets and improve retention with family-friendly elephant activities. Babar is the sponsor for this bet and he thinks it’s worth $6mm in present value, and he’s willing to spend up to $5mm to try to make it work.

To calculate the value of those categories, we took a back-of-the-napkin approach where we estimated the size of the market and our ability to sell into that market. There’s certainly room for more rigor, and I encourage you to talk to your finance team about how to improve the model.

But do remember that it’s all still guesses at the end of the day. It’s better to have some model than a perfect model. The real benefit is in shifting the conversation from features and dates to about being accountable for value.

We may be a foreign country, but we can still speak our business partners’ language.

[beat]

But how do we get them to talk to us?

A leader I respect once told me, “You have 18-24 months after becoming VP of Engineering to make a difference. After that, the organization’s problems become your problems.”

I think he was right on target. As a leader, your colleagues in other departments will reserve judgement for the first six months or so. They’ll get impatient over the course of the next year. By the end of two years, they’ll be holding you accountable. If you don’t define what that looks like, they’ll define it for you, and they’re going to default to features and dates.

The problem with product bets, as an idea, is that they require leadership participation. You can’t create these spreadsheets on your own. Even if you did, nobody’s going to pay attention if you don’t have their buy-in. I’ve tried variants of the product bet idea many times over the years and getting that participation has been extraordinarily difficult. I’m a little surprised we’re able to do it at OpenSesame, to be honest.

Before you can get people to buy in to your definition of accountability, you need them to trust you. And in order for them to trust you, you need to be accountable.

I’m not sure how to solve this chicken-and-egg problem for your organization. I can tell you how I solved it for mine. Any change you introduce has to be in the context of your specific situation, so I’m not saying that you should do it my way. Some of my changes were pretty radical, and they’re not going to be a good idea for every situation.

We don’t have time to go into every detail, so this is going to be more of an overview than a how-to guide. I’ll provide resources for further investigation.

QR Code: FaST: An Innovative Way to Scale

When I joined OpenSesame, I started by getting the lay of the land and deciding what to do. One of the things I saw was that the teams were heavily siloed by technology area, rather than by product line. Cross-team delays weren’t too bad, although they often can be in this situation, but it did mean that teams’ work didn’t line up to our business needs. So the first thing I did was to introduce Quentin Quartel’s Fluid Scaling Technology, or FaST.

We don’t have time to discuss FaST today, but you can learn more about my approach to it by following this QR code. The short version is that we combined teams into product-centric “collectives” and created a single queue of work for each collective. Each product has a dedicated collective and work queue. Those collectives self-organize into teams as needed to tackle the highest priority work.

FaST solved the problem of teams not matching business needs. A related problem was the teams planned their work in terms of technical priorities rather than business results. They called them “stories,” and “epics,” and recorded them in Jira, but they were more like technical tasks. At the same time that I introduced FaST, I also introduced the idea of “Valuable Increments” from my book. (In case it’s not clear on the slide, my book is The Art of Agile Development, and it’s now available in a second edition. You can find this material in the “Adaptive Planning” section.)

A valuable increment is a similar idea to an epic, in that it groups together multiple stories, but an “epic” is literally a “big story.” A valuable increment isn’t focused on size; it’s focused on value. Each VI is something that stands alone. When it’s done, you can release it, and you’ll have gotten value out of it even if you never work on anything related to it ever again.

Introducing FaST and VIs allowed me to talk in terms of the business results my teams were creating for each product line, not just their technical accomplishments.

I also knew, from experience, that one of my biggest battles was going to be around estimates and forecasting. Before I could gain the trust of the organization, I needed to be able to demonstrate that I could do what I said I would. Up to this point, their experience of software development was that we never delivered on time. At the same time, I didn’t want people to over focus on features and dates.

So I played a game that, to this day, I’m not sure was the right approach. I had my engineering managers start collecting data so we could provide more accurate forecasts. While they did that, I told teams to stop providing estimates to stakeholders.

This caused a lot of anger in my stakeholders. They didn’t like hearing that they couldn’t have estimates. I told them that our estimates weren’t accurate, and we were working on getting better information, but they still didn’t like it. I think I only got away with it because there had been high-profile failures with the old approach, and I was still in my honeymoon period, but it still caused a lot of friction.

It worked out in the end, I think, because the new forecasts really are much more reliable, but I had to collect data for about six months before I could provide the new forecasts. That was an uncomfortable period. I could have kept the old approach to forecasting, but it definitely didn’t work. I’m not sure if “wrong estimates” would have been better than “no estimates.” On the one hand, a clean break meant that it was obvious that I had switched to a new approach, and—as I said—it really works. On the other hand, I made some important members of the leadership team angry in the meantime.

Anyway, the way it works is that we get a “wisdom of the crowd” estimate for each VI before works starts. That involves a product manager providing a very brief description of what the VI involves—just a minute or two of verbal explanation. People can ask clarifying questions, but there usually aren’t many. Then everyone provides their gut feel of how long the work will take a team to accomplish, in weeks. We collect the answers without discussing them and record the median response. That’s the estimate. It only takes a few minutes per VI. Since our collectives have between 12 and 25 people, including managers, product managers, and designers, there’s enough people to make the “crowd” part of “wisdom of the crowd” work.

Our Wisdom of the Crowd estimates are stunningly accurate. The median estimate for a VI actually matches the median reality. It’s amazing. The approach comes from Quentin Quartel and his FaST method, and I’ve never seen anything so good. It’s easy and it’s accurate.

However, although Wisdom of the Crowd estimates are accurate, in aggregate, they’re not very precise. We graph estimates versus actuals—you can see it on the right there. About 30% of VIs take twice as long as estimated, and about 30% take half as long as estimated. That’s a pretty big range.

So we don’t present the raw estimates to stakeholders. If we did, we’d be late half the time. Instead, we increase the estimate so we’re early more often than we’re late.

Doing this requires me to play a political balancing act. According to our data, never being late would require us to multiply our estimates by six or seven, and that wouldn’t fly. We can’t tell them that a small, two-week VI is going to take 3-4 months. On the other hand, it’s also not acceptable to be late half the time.

Right now, I’ve chosen to be 75% accurate. In other words, we’re early 75% of the time and late 25% of the time. For us, that’s about a 2x multiplier, depending on the team. I’ve also told stakeholders to expect about 1 in 4 VIs to go longer than expected. So far, it’s working well.

If you’d like to know more about the analysis behind this technique, it’s in my book in the “Forecasting” section.

Collecting all that data for forecasting had a side benefit. My CEO pushed me to report productivity—that’s a whole ’nother story—and I decided to do it by reporting the percentage of time spent on muda versus the percentage of time spent on adding value to the business. Muda is activity that doesn’t add value. It’s the grey sections in the graph: maintenance, bugs, and on call.

This isn’t the real graph, for confidentiality reasons, but the story it tells is all too familiar: lots of time spent on deferred maintenance, lots of time spent on incidents, lots of bugs. And then just a fraction of time left over for doing valuable work.

I shared the real version of this graph with my leadership team and it was eye opening. All of the sudden, they understood exactly why things took so long, and why they didn’t ever get what they wanted. They had thought we had way more capacity than we actually did.

I told them that my responsibility was to reduce muda—the grey part—and make more room for valuable work—the blue part. That was an act of deliberate accountability, and it flipped the script. Yes, people still wanted me to be accountable for making teams deliver feature X on date Y, with all the fighting about deadlines that involves, but even more importantly, and primarily, I was accountable for decreasing muda. That’s precisely what I needed to be focused on, because that was our biggest problem.

And, over the past two years, that’s exactly what I’ve done. I report on my progress every quarter, and every quarter it’s a little bit better than it was before. And every quarter, I get a little bit less pushback on predicting dates.

And then, finally, I just kept pushing. These two books are excellent resources on how to do so.

I introduced the original variant of the product bet idea in January 2024, or maybe even earlier. It didn’t go anywhere. I brought it up again in March 2024. We sort of tried it, without leadership buy-in, and it sort of fizzled. I brought it up again, and again. I worked with my colleague, the VP of Product. I talked to the Chief Product Officer. I included it in a presentation to leadership about how Agile works. I piggybacked on the CEO’s passion for quantifying results. I stopped asking Leadership to create financial models and just created my own, then asked them to fill in the values. (That’s why they’re not very rigorous.)

And then finally, in March of 2025, the stars aligned. The CPO started pushing the rest of the leadership team to get involved. We created five product bets, the leadership team filled in my spreadsheet, and we started working on the first bet. And now we’re off to the races. We just started our second bet a few months ago, and we’re talking about how to increase capacity for more bets.

There’s lot more to do, and lots more to learn, but now that the logjam has broken, I think it’s going to stick. Our new CFO is intrigued and I’m able to show steady progress with my VIs and forecasting techniques. I’m well on my way to erasing the stigma that engineering can’t be trusted to deliver. I had 18-24 months to make a difference. I’ve just passed my 2nd year at OpenSesame, and I’m still here. I think it’s going to work out.

Software development may be a foreign country to the rest of the business, but we can still be a trusted part of their empire.

To do so, we have to take accountability, rather than allowing it to be forced upon us. Rather than falling into the habit of delivering X features on Y date, we can be accountable for what really matters: results, just like our colleagues in sales, marketing, and other parts of the business. And the results we create are new opportunities. Enabling more prospects. New partners. More leads. Better retention.

Product bets allow us to be accountable for the estimated value of those results. So far, they’ve been working for me. I hope they work for you, too.

No more writing code

🦉 olshansky 🦁 — Sun, 19 Oct 2025 00:40:47 GMT

I can never see myself writing code by hand again.

It feels like doing multiplication and division with large numbers before there was a calculator.

While the agents are working, I’m reviewing, editing, and staying in context.

Basically, I’m only typing to think, not to do.

The design space of AI coding tools

Austin Z. Henley's Blog — Sat, 18 Oct 2025 23:00:01 GMT

https://austinhenley.com/blog/aidesignspace.html

So what is Open Source Software in a Source Available Software world?

unsungNovelty — Sat, 18 Oct 2025 11:57:49 GMT

Open Source Software(OSS) has gone through a lot of battles over the years. The recent two of ’em has been from source available software licenses and Large Language Models (LLMs). Source available predates the LLM/AI trend (in it’s current form). And source available software has a renewed interest. So many think Source Available Software (SAS) is the answer. The next step for OSS software. So I thought this is a good time to define what OSS is. This is my gentle attempt to explain the what, why and how of OSS. And why it is still important for us to rally for Open Source Software.

So, what is Open Source Software?

The whole point of OSS was to provide software with 4 freedoms:

To run the program
To study and change the program in source code form
To redistribute exact copies
To distribute modified versions.

The idea was to encourage software that can be tinkered. And also be used for any purposes as long as you comply by the very few restrictions which guarantees the freedom mentioned using OSS licenses. The idea behind Open Source wasn’t about capitalism vs socialism. Or big corporations vs the small guy. Or making money vs not making money. It was the rejection of proprietary software. So that the developers and the users irrespective of their size can use and make it into what they want. It was a fair system providing equal grounds for everyone involved. It doesn’t always work the way it’s supposed to be. But that is another problem. And it won’t be solved by creating new problems.

Free as in freedom (Open Source) and free as in beer (Source available)

You might’ve heard of people explaining open source as free as in freedom and not free as in beer. What this means is the “free” in OSS is supposed to be about the freedom it provides to consumer. That is to learn, use, modify and distribute the software/source for any purpose (the free as in freedom). And not whether the software is free or not with respect to monetary value (free as in beer). In fact, there is no need for open source to be free from a price POV. The Free Software Foundation encourages you to make money from OSS. This is why, back in the day, people used to make copies of Ubuntu CDs and sell it for a price. It was all legal to do.

What is Source Available Software?

Source available software means the source of the software is available for you to read. But doesn’t provide the freedoms of OSS software. In most cases, the restriction is about forking or redistributing. Essentially, whether it is FUTO, Bear Blog, Terraform or Liquibase, it’s always about control or money.

One of the most common Source Available Software license is Business Source License. You can read more about the different types of SAS licenses here.

Why don’t you like Source Available software?

I don’t have a dislike for Source Available Software. I think we all have the freedom to make software in whatever form we would like. Distribute it the way we would like. I mean, it is our software after all. But I do have a problem with Source Available Software folks source washing OSS. Trying to make it look like OSS is taken advantage off and is weak to solve the problems of the present. It shows clear misunderstanding of what OSS is about. The so called perceived weakness is what makes OSS so strong. It is those “weakness” that has made it flourish.

But Big Tech is taking advantage of the small guys!!

NO. It’s OSS working as it is supposed to be. This is one of the freedoms that it provides. The right to redistribute and modify. It was not taking advantage. Amazon or other companies are exercising their right to fork and redistribute. What this shows if not anything is misunderstanding of the OSS licenses. Illiteracy of it. Which is a problem we should be solving cos it is hard to understand. Companies and people using OSS have pikachu faces when they suddenly realise others can fork and redistribute the software. If that was a bother, I would tell you that you didn’t want OSS in the first place. Or that you were using the wrong OSS license. Or didn’t know what you are getting into. Maybe you didn’t expect your software grow this big. Be in a spotlight like it eventually did. But the issue is clearly that you changed. Not OSS. Also, you can track the code smell of it all back to somebody is making money or have used my OSS in ways I don’t approve off. It was the same thing with Redis, Elastic and recently with Bear blog. And that is the exact reason why OSS came about. Because proprietary softwares under End User License Agreement (EULA) lecture how a program can be used. This was one of the reasons whay OSS was created. Clearly, with SAS, we are coming back full circle.

Not to mention, it works both ways. You can fork any Amazon’s OSS and spin up a SaaS as well. This is literally why Cursor exists. Because they forked VS Code to make it their own. And this is where SAS lacks. If VS Code was licensed using source available licenses, Cursor wouldn’t have been possible. The software industry in it’s current form exists because of OSS. With SAS, it is only about money and control disguised as limiting “OSS can fork or redistribute” freedom. This means, OpenTofu wouldn’t have happened if Terraform was SAS in the first place. MapLibre wouldn’t have been possible when Mapbox GL JS became closed source. This is the future so many of the SAS folks are so excited to bring up on to the OSS communities. Listening to these companies using their money and good marketing campaigns about OSS being weak. It is going to make it harder for the small guys to fight against big techs.

Then there is the VC companies crying BIG Tech killing us sob story. Redis and Elastic when they changed to source available licenses had at least a hundred million dollar in funding (This is a humble under cutting. For example, I know it was at least 200M+ in redis’s example at the time of license change). So the helpless, weak crippling companies narrative is not true. Both of them has since changed the license back to an Open Source license though. This was the case with HashiCorp as well. But they stuck with Business Source License.

Why is forking and redistributing possible with OSS and why is it important?

The freedoms of OSS which allows you to do the below allows you to fork a software.

To run the program
To study and change the program in source code form
To redistribute exact copies, and
To distribute modified versions.

These freedoms are extremely important. Because without these freedoms, there wouldn’t have been forks of popular OSS projects when they went against the OSS community or consumers. If you are bothered about people using your software in ways you don’t want to, then you didn’t want OSS from the start. At least in Herman’s case, I understand the difficulty of this. But I also remember us discussing Mapbox forks which used to crop up regularly in Mapbox slack workspace. New websites cropping up with forks of Mapbox OSS libraries with even the same Mapbox website design. And none of them made it you know. Clearly AI is a different problem altogether. As Herman notes in his post about the license change, free loading is going to increase. But at the same time, that was always possible. And “free loading” (a.k.a right to redistribute) as he puts it is one of the OSS freedoms. Maybe it wasn’t possible in the current LLM speeds. But still, it’s not a new issue.

Not to mention, software is not the only thing in a business. I don’t think a fork alone will allow people to create a competing service. Other than that, I would say people are not always looking for just the functions in a software when they are choosing OSS. While I do agree that SAS has a barely slight advantage of the source being available. You have no idea what the project will become tomorrow. And when it changes, you have zero control over it. It’s like investing a huge amount of time on a software project and when they shuts you down (what’s up x.org ??), you wouldn’t be able to do anything. This is why I don’t think SAS can have the level of community involvement OSS always will have.

But if you want good software, you should pay!

Yes. Pay for OSS services. Donate when possible or contribute in ways possible. Majority of the server software which will make it possible for you to read this post runs of OSS. There are many pieces of OSS project which are community based and are from commercial companies as well. Nobody is saying it should be free. Just don’t butcher the OSS movement. And let’s keep SAS separate and we are all good. If projects are not ready to provide OSS freedoms, you also cannot piggy back on OSS for good PR.

So what is your solution?

The solution is to use the right OSS license depending on the project and business you want to do. And not to mention, doing OSS business is hard. There is no denying it. It has been written about a lot of times. Death of an Open Source Business Model by Joe Morrison is a great piece on that subject. And Drew Devault has written about his POV here. Whcih talks about the pain points Herman and others mentioned about OSS. While I personally don’t think it is dead as per the former article, I also don’t think OSS model will work for all types of businesses. For certain businesses, OSS can be a boon and for others it is impossible to make a business out of it. SAS can provide confidence by making source available to read. The verifiability of it on backend is the first problem. But also, I don’t think it makes sense if it comes at the cost of OSS. It is a very very bad move for the software community. If you want to make money and don’t want to share code, I personally think making a proprietary software is better. Then contribute back to OSS communities via donation, contributions or by other means. Creating new problems for OSS and butchering OSS is not the way to go about it.

Python is faster because of Microsoft’s recent investment.
React changed UI library with Facebook money.
Linux Foundation and Rust Foundation are run by companies which a lot of OSS folks dislike.

Money is a problem in OSS. There are different ways to solve this. But to most, they want to ignore it. Which is why we have things like SAS. Be Microsoft for Python. Be Jane Street for OCaml. Or do it the community way like Zig foundation, FreeBSD foundation or OpenBSD foundation. But let’s keep OSS the way it is. And the way it always has been.

Wrote something wrong? Happy to listen. Drop an email to nikhil at unsungnovelty dot org.

Reminiscing about Turbo Pascal

I Learnt — Sat, 18 Oct 2025 11:54:00 GMT

Sometimes you come across a video that brings back memories.

Magical Thinking is the belief that your thoughts ...

Kevin B. Ridgway's Blog — Sat, 18 Oct 2025 05:25:57 GMT

Magical Thinking is the belief that your thoughts alone is enough to affect the world. Success requires both appropriate action and realistic assessment of what's actually possible.

Just do it or you can just do things.

Critical thinking with concrete action. Always.

Photos from October 18th, 2025

cjlm.ca — Sat, 18 Oct 2025 03:00:00 GMT

How to Actually Copy a List in Python

Nelson Figueroa — Sat, 18 Oct 2025 03:00:00 GMT

Copy a list in Python using the copy() method, not the assignment operator.

C++ Threads - There is a Right Way and a Wrong Way but the Wrong Way is Probably Fine

Andrew's Blog — Fri, 17 Oct 2025 22:02:26 GMT

A recent post on one of the C++ subreddits caught my eye. It has since been deleted but I thought it illustrated an interesting point.Paraphrasing from memory:These are good questions...

Apps disappearing from my android phone

unsungNovelty — Fri, 17 Oct 2025 21:04:13 GMT

Ike Pro was the first app that I bought with my own money from android play store. It was a to-do list app which introduced me to Eisenhower Matrix. This has been my favourite way to prioritise tasks ever since. Coming from a Linux / OSS environment (and being naive and young), paying for an app was way too new to me. But the price was justified and the quality of the app was good.

I used it for a long time. And after a while, even though I wasn’t using it a lot anymore, I still used to come back to it. And after a long gap, I decided to start using the app regularly again. I knew I have it installed on my phone. So, I searched for it only to find that it’s not on my phone anymore. The last time I used it was on my 3rd phone since I bought the app. Searching on the play store made me realise that it wasn’t listed anymore. Given that I knew it wasn’t updated in a long time, I thought OK, maybe I uninstalled it. Cos I regularly cleanup my phone’s files and apps. But I didn’t find any app good enough like Ike. Not even now, when Eisenhower matrix based apps are finally picking up steam.

The same thing happened again today morning. But this time, it was Aegis - the TOTP authenticator. A far more serious issue. The app was v2.x which cannot be upgraded to v3.x because of some compatibility issue. While I had migrated most of my 2FA codes to another app, I didn’t do the same for some rarely used app logins. I don’t remember why. While it is true that it was my mistake to not update the app for so long, I can’t stress enough that the app was working perfetcly fine. It was an offline only app. For now, I can search my phone and it opens my app info page for Aegis. From here, I can open the app. But I don’t know how long that will work. And I am not sure if google will delete it like they did for Ike. Or did they? I really don’t know. But I will keep a close eye this time.

android’s google problem

The never ending cycle of developers having to update the app for googles api changes have killed solo devs like Ike. Only apps left are the big tech, VC funded or scammy spywares. Excuse is always security. But the fact that we cannot keep enough backward compatibility anymore saddens me. Or the fact that we are unable to make reliable app which doesn’t need to be updated regularly. Especially the offline-only apps which can eventually be considered finished. Not to mention the random policies that can make a perfectly fine app disappear from your phone.

If Jenny Spurlock and Long Ma, the creators of Ike to-do are reading this - thank you! I bought the app in 2016. And I still remember it after almost a decade.

Design of a Wild Shape/Polymorph Decision Aid

ℤ→ℤ — Fri, 17 Oct 2025 18:22:41 GMT

In Fifth Edition (5e) Dungeons & Dragons™ (D&D), druids can transform into certain Beast forms using the Wild Shape ability. Similarly, casters of the Polymorph spell can transform allies and enemies into Beasts. Players often find selecting a Beast form onerous (there are 84 forms defined in the System Reference Document (SRD) alone) as this is a multi-dimensional decision problem. We created an online tool to aid in the decision process. Our tool presents two synthetic metrics to capture offensive and defensive strengths in combat and assigns beasts to one of four labels (combat, explore, water, and sky) based on the results of machine clustering. In this article, we discuss the user interface and the data science used by the tool.

Motivation

Game designer Sid Meier has stated that “Games are a series of interesting decisions". In D&D, transforming a creature into another form, as the druid’s power of Wild Shape or the spell Polymorph allow, is an interesting decision by Meier’s definition. The decision is situational, where a player needs to consider the current environment and other constraints, how the new form will impact the group’s ability to explore and combat foes, and if the transformation is worth the resource trade-off.

The choice can be difficult. While both Wild Shape and Polymorph restrict the transformed form into a Beast, a creature type that encompasses real-world natural creatures such as spiders, wolves, dinosaurs, and giant-sized variants, this is not very restrictive in practice as players will have dozens of potential Beast forms to choose among. Further, while the pool of Wild Shape forms has to be selected ahead of time (four to eight slots, with one slot swappable per Long Rest), Polymorph forms are selected at the time of casting. Selecting a form can thus slow down the game, particularly during combat, as the caster looks through their options.

As players, we have experienced this difficulty and wanted to make the selection faster and with greater confidence. Commonly, beginning players follow the rule book’s suggestion of Rat, Riding Horse, Spider, and Wolf (SRD, pg. 42), but as we discuss near the end of the article, we believe this recommendation can be improved. Experienced players tend to create spreadsheets to help them make these decisions and have the statblocks ready at hand during play. Although creating spreadsheets is a signal of engagement, we do not want the process to require this level of commitment.

We decided to build a tool. Our objectives:

Useful for the 84 beasts in the SRD, but methodologically expandable to other bestiaries. Many authors have created listicles ranking Beast forms, but we would like a solution that can scale to the 400+ products on DM’s Guild with new Beast forms or the 1200+ Homebrew Beasts on D&D Beyond with a rating of 2+.
Require fewer rules lookups and implicit filters than D&D Beyond.
Reduce time and effort spent by players by amplifying the distinctions between Beasts.

Examples

In the D&D movie Honor Among Thieves, the druid Doric transforms into a horse to hide in plain sight among a group of mounted knights. The horse form allows Doric to infiltrate the group, whereas other forms might arose suspicion. In this case, the form is highly situational, but normally the druid will need to select forms that fulfill many potential scenarios.

Wild Shape Combat Selection

A player of a 3rd level druid is swapping out a Wild Shape form ahead of a trip into a large, natural cave network. The party is in pursuit of a bandit gang. The party consists mostly of spell-casters and the druid is expected to hold the front-line in combat.

Using the tool, the player first selects “Druid, Level 2-3” under Show Beasts. This filters the list to Beasts with challenge ratings between 0 and 0.25 and removes from the list any Beasts with a Fly speed (per the game’s rules for Wild Shape). The player looks at the Combat Fitness plot.

Combat Fitness Chart: Beasts available for Level 2 Druids

In combat, dealing damage is less important than holding the line, so the player looks at options with higher defensiveness scores (Tank). The top four options by Tank are the Giant Crab, Giant Lizard, Giant Badger, and the Giant Frog (we present the data using an inline table rather than a screenshot for accessibility):

Beast Name	CR	Role	DPR	Tank	Senses	Actions	Specials
Giant Crab	⅛	Water	2.80	52.00	Blindsight 30 ft.	Claw	Amphibious, Stealth +3
Giant Lizard	¼	Explore	4.50	47.50	Darkvision 60 ft.	Bite	Spider Climb
Giant Badger	¼	Fight	4.80	42.96	Darkvision 60 ft.	Bite	Perception +3, Resists: Poison
Giant Frog	¼	Water	3.50	40.00	Darkvision 30 ft.	Bite, Swallow	Amphibious, Standing Leap, Perception +2, Stealth +4

The player chooses the Giant Lizard. Although all four forms have something to recommend themselves, the Giant Lizard has Spider Climb, which allows it to climb along the walls and ceilings of the cave. The Lizard has excellent ability to operate in the dark environment of the cave, although if the bandits were known to use obscuration, the Giant Crab’s blindsight might be preferred. Similarly, if the bandits were known for using poison, the Giant Badger’s resistance would be a great asset.

Polymorph Selection

The party of a seventh-level wizard are exploring an underwater kelp forest. The wizard considers casting Polymorph on their sixth-level ranger to explore the area faster. Within the tool, the player chooses “Beasts with max CR 6” (the level of the ranger) and sets “Require Movement Speeds” Swim.

Combat Fitness Chart: Beasts with CR 6 and below with Swim

Since the purpose is exploration rather than pure combat, the player looks at a range of beasts, sorting by challenge rating, and focusing on senses. The Killer Whale pops out of the list with a Blindsight range of 120 ft which will allow it to rapidly map the underwater terrain, even with obscuration from the kelp plants. If the Killer Whale encounters combat, it is still one of the more deadly underwater creatures even though it only has a CR of 3. Unlike Wild Shape, Polymorph uses the Beast’s stat block skills so the Perception +3 and Stealth +4 also assist the purpose of exploration.

Beast Name	CR	Role	DPR	Tank	Senses	Actions	Specials
Giant Crocodile	5	Water	37.05	283.33	-	Multiattack, Bite, Tail	Hold Breath, Stealth +5
Giant Shark	5	Water	22.00	262.86	Blindsight 60 ft.	Multiattack, Bite	Water Breathing, Perception +3
Archelon	4	Water	11.90	600.00	-	Multiattack, Bite	Amphibious, Stealth +5
Hippopotamus	4	Water	14.40	273.33	-	Multiattack, Bite	Hold Breath, Perception +3
Killer Whale	3	Water	17.85	225.00	Blindsight 120 ft.	Bite	Hold Breath, Perception +3, Stealth +4
Giant Constrictor Snake	2	Water	9.35	150.00	Blindsight 10 ft.	Multiattack, Bite, Constrict	Perception +2, Stealth +4
Hunter Shark	2	Water	11.90	112.50	Blindsight 60 ft.	Bite	Water Breathing, Perception +2
Plesiosaurus	2	Water	9.35	194.29	-	Bite	Hold Breath, Perception +3, Stealth +4

A Note on References

Wizards of the Coast publishes the D&D rules in two different ways: a set of commercially available books and the System Reference Document. The former contain rules and flavor which make D&D a recognizable set of fantasy worlds while the latter solely enumerates mechanics and “generic” spells and monsters. For example, beholders are an iconic monster in D&D and are detailed in the commercial books but are not included in the SRD. Wizards of the Coast licenses the SRD under the Creative Commons (specifically, CC-BY-4.0), allowing other publishers to produce products compatible with the ruleset. Thus, following the license, we reference the SRD, not the Player’s Handbook or Monster Manual.

A Note on Editions and Versions

The D&D rules have evolved over many editions. Fifth edition is the current edition at the time of writing. The first version of Fifth Edition was released in 2014 and is covered in the SRD version 5.1. A second version of Fifth Edition was released in 2024 and is covered in the SRD version 5.2. Our tool uses the mechanics and stat blocks described in SRD version 5.2.1.

User Interface

The tool’s user interface is displayed in the figure below. Filter controls are featured along the top and below the fold is a visualization of combat fitness and a table with the matching beasts.

When a player interacts with the tool, we expect they come either oriented as a druid character or as a caster of Polymorph. Thus, the first and primary filter (“Show Beasts”) either operates to filter by the Wild Shape criteria for a druid’s level or the challenge rating filter for Polymorph. Since subclasses, homebrew, and other spells (such as Animal Shapes) may modify what is considered a valid Beast target, we provide some additional options to cover likely cases. However, the list is not inclusive of all possibilities. For example, Animal Shapes restricts forms to Large and smaller in size, but none of our controls filter by size. As an 8th level spell, few players will ever cast Animal Shapes and we have tried to balance likelihood of use versus flexibility.

The existence of a movement speed operates as the secondary filter. Movement speeds act as a proxy for environment (creatures without a Climb or Swim speed can do both, but at a penalty) and, in our experience, druids will often reserve a slot for access to an unusual environment.

The third filter is a free-form field that restricts by textual prefix matched against a creature’s list of actions, traits, and similar fields. Our hypothesis is that the third criteria players will use will tend to focus on specific abilities. Since the universe of “specials” is small, we could use a drop-down, but we have left it as an open-field since we may need a more flexible filter, such as one that allows exclusive filters (“not”).

User Interface at 67% Zoom

The Combat Fitness Plot (shown expanded in the screenshot) positions beasts matching the filter by their DPR (damage per round) and Tank (hit points scaled by difficulty of being hit) scores, or roughly their offensive and defensive strength. (See “Interpreting Combat Effectiveness” section below for more details on these metrics.) The plot can be hidden since 1) players may not be interested in the combat fitness scores 2) most displays will require vertical scrolling to show the current filter, plot, and table and 3) encourage players to focus on the table. We have kept the plot because, in our experience, we found it quickly summarizes the basic combat effectiveness of creatures and helps players focus on differentiating factors.

Our table has columns for challenge rating, suggested role label, DPR score, tank score, list of unusual senses, list of actions, bonus actions, and reactions, and a list of specials which includes skills, traits, and similar fields. In comparison, the leading D&D data source, D&D Beyond, displays columns for challenge rating, creature type, size, alignment, habitat, and tags (which is usually blank). Both tables include links to full descriptions of a creature. D&D Beyond’s choice of columns (which are fixed in their UI) are meant for high-level encounter design. A game master building an encounter may be interested in monster alignment and habitat to fit world-building flavor, and is not restricted to Beast as a creature type, but these fields are irrelevant to a druid or caster. (Also, from a license perspective, creature habitat is not in the SRD.)

Interpreting Combat Effectiveness: DPR and Tank Scores

Combat in 5e is highly tactical, incorporating positioning, cover, constrained movement, choice of attacks, and varied spells and special abilities. However, Beasts, being modeled after real-world creatures, tend to have more straight-forward combat tactics than, say, a Gibbering Mouther which creates difficult terrain, can mind control opponents to act randomly, and has a rechargeable area of effect attack. Thus, our hypothesis is that we can capture a useful portion of a Beast’s combat effectiveness with two metrics.

We propose two metrics: Damage Per Round (DPR) and Tank. DPR is the expected damage to an opponent with AC 10 if the Beast uses all their attacks against the same foe. Tank is the creature’s hit points adjusted by their AC as if they were being attacked by an average human (Attack +0). Both metrics ignore any situational adjustments or special abilities. For instance, in combat Giant Frogs and Giant Toads will attempt to swallow opponents, rendering them Grappled and thus impaired on their attacks, but in our model, they never do. Similarly, apes are unusual among Beasts because they have a ranged attack (throwing rocks), but this model does not consider the advantages of attacking at range.

Challenge Rating

Challenge Rating is a pre-existing metric that serves to “summarize the threat” (SRD, pg 178) of a monster. While useful (we include it in the tool’s table), we feel it is insufficient as a metric of combat effectiveness. First, it insufficiently differentiates monsters. A 2nd level Druid will have access to Beasts with three challenge ratings: 0, ⅛, and ¼ with roughly a dozen Beasts in each category. However, a Giant Crab and a Venomous Snake, both CR ⅛, operate differently in combat, with the Giant Crab acting as a defensive sponge of attacks, while the Venomous Snake is more of a glass cannon. CR is too imprecise.

Damage Per Round (DPR)

Damage Per Round models a creature’s melee and direct damage attacks using their attack bonuses and expected damage scores. This score underestimates the deadliness of creatures with special abilities and unusual traits, while sometimes overestimating the damage output. For instance, many snakes inflict both Piercing and Poison damage and thus measure highly on DPR. However, if the opponent has Poison resistance, a snake will be of little threat. Plotting DPR against Challenge Rating shows a large variance of scores within a single CR category. The Pearson correlation score between the two metrics, across all monsters, is 0.59, a moderately positive correlation.

Boxplot of DPR by Challenge Rating

(The CR-1 outlier is the “Pirate”, a non-Beast monster whose attack is written in an unusual format which does not match our Beast-oriented stat block regular expression. Calculating DPR for monsters, particularly higher challenge-rating monsters, is difficult due to the variety of attacks and special defenses.)

Tank

Tank is the equivalent hit points of a creature if we adjusted their AC to 10. This model ignores other defensive traits like resistances and immunities, but these are rare among Beasts. 5e’s design incorporates a concept called “bounded accuracy” where the curve of improvements in AC is suppressed so more attacks will hit. To compensate, hit points are increased compared to previous editions. When we plot Tank scores by Challenge Rating, we can see that the percentiles follow a curve. Across all monsters in the SRD, the Tank score has a Pearson correlation score of 0.88 with the monster’s Challenge Rating, a strong, positive correlation.

Boxplot of Tank by Challenge Rating

(The CR-1 Tank outlier is “Animated Armor,” a Construct made of Plate Armor that is tough and has a high armor class.)

Clustering Beasts by Role

Early users provided feedback that it would be useful if beasts were labeled with a specialty or role. Although manually assigning labels is certainly feasible for the 84 beasts in the SRD, we wanted a method that could scale to the far greater number of beasts that exist in homebrew and in non-core rulebooks. Thus, we decided to use a machine clustering approach to discover existing but implicit groupings of Beasts.

Based on our experiences and Internet commentary, we expected the algorithm to find three roles: a combat role (with mostly carnivores), a reconnaissance role (with flyers, burrowers, and stealthy creatures like cats), and a mobility or utility role (with horses, mules, and other beasts of burden). Instead, the algorithm found four clusters (roles). Two of the roles reasonably match the combat and reconnaissance roles, but the other two roles were environment-based: water-based creatures and flying creatures.

As a contrast, the 2016 Unearthed Arcana: Druid document has “combat, climbing, stealth, and serving as a mount” as the list of suggested roles. We similarly found a cluster for combat. Our Explore cluster contains most of the “climbing” beasts and those that can serve as stealthy explorers, although Stealth by itself was too common a skill to be a differentiator between clusters. (Since Stealth is a skill, the Wild Shaped creature will have the greater Stealth score of the original form and the beast form.) Mechanically, a mount is any creature at least one size larger than the rider and with “appropriate anatomy” (SRD, pg. 15). Our algorithm did not find a “mount” cluster because “appropriate anatomy” is flavor, not a quantitative element found in the monster’s stat block. The lists of mounts in the SRD are tied with historical examples, such as mastiffs, horses, and camels. However, would a game master really rule that a character couldn’t ride a (willing) polar bear because it lacked an “appropriate anatomy”? Thus, “serving as a mount” seems to be a role only if a game master requires it.

Philosophically, is an unsupervised approach more valid than a supervised approach where we specified the clusters and let the computer fit a classification function? Unsupervised is a bit of misnomer because we chose the features that went into the algorithm and iterated until the results seemed “good,” based on both our understanding of the beasts and quality metrics. Although there is some bias, we believe our methodology is defensible as evidenced by the fact that the results were not what we expected initially. (One bias, we will admit, is a focus on the mechanical stat block aspects of each Beast. A mobility role may appear if we included features such as “saddles for this beast can be bought” or carrying capacity.)

If we had chosen a supervised approach, we would need validated labels for each beast in the training set. However, although there are suggested roles in the rulebooks, there are no canonical roles for each Beast. Each guide approaches the decision differently. We could create and validate labels under some role schema, but we would then be bending the data to our labels, rather than letting labels emerge from the data.

Thus, we think our clusters, delivered through an unsupervised approach, are more indicative of the reality of the rules than ad-hoc clusters imposed on the beasts.

Methodology

Through iteration, we tested a variety of encodings for beasts, evaluating the results visually using a two-dimensional principal components analysis (PCA) plot and using the silhouette metric. The groupings of columns were chosen based on their similar nature within the game. Some traits were very common so they became their own columns, such as “Pack Tactics”. The Oddball column may be seen as a violation of the approach, but beasts with Oddball traits did not congregate to their own cluster.

After experimentation, we ended up with the following set of twelve columns:

COLUMNS = ['Has Burrow', 'Has Climb', 'Has Fly', 'Has Swim', 
		'Combat', 'Nimble', 'Pack', 'LandWater', 
		'Oddball', 'Jumping', 'Web', 'Water Breathing']

Notably, neither Challenge Rating and Tank (as both a score by itself or as an “outsized” binary value) were found to be useful features. For is_outsized_dpr, we treated a challenge rating greater than 1 as always outsized, while we measured the lower challenge ratings versus the median values within the SRD. Because there are so few examples of Beasts with higher challenge ratings, we found that the error in the measured median was too great. Furthermore, Perception and Stealth skills were too common to usefully differentiate clusters.

Our encoding logic:

def is_outsized_dpr(m) -> bool:
    if m['challenge_rating'] > 1:
        return True
    else:
        med_dpr = {0.0: 0.75, 0.125: 3.0, 0.25: 4.5, 0.5: 4.2, 1.0: 6.4}
        return m['damageness'] >= med_dpr[m['challenge_rating']]

def intersection_size(a, b) -> int:
    set_a = set(a)
    set_b = set(b)
    return len(set_a.intersection(set_b))

def monster2array(m: dict):
    arr = np.zeros(len(COLUMNS))

    arr[COLUMNS.index('Has Burrow')] = int('Burrow' in m['speeds'])
    arr[COLUMNS.index('Has Climb')] = int('Climb' in m['speeds'])
    arr[COLUMNS.index('Has Fly')] = int('Fly' in m['speeds'])
    arr[COLUMNS.index('Has Swim')] = int('Swim' in m['speeds'])

    arr[COLUMNS.index('Combat')] = int(is_outsized_dpr(m)) 
    	+ int('Multiattack' in m['actions_summary']) 
    	+ int('Bloodied Fury' in m['specials'])
    arr[COLUMNS.index('Nimble')] = intersection_size(m['specials'], ['Agile', 'Flyby'])
    arr[COLUMNS.index('Pack')] = int('Pack Tactics' in m['specials'])
    arr[COLUMNS.index('LandWater')] = intersection_size(m['specials'], ['Amphibious', 'Hold Breath'])
    arr[COLUMNS.index('Oddball')] = intersection_size(m['specials'], ['Beast of Burden', 'Compression', 
    	'Illumination', 'Mimicry', 'Resists: Cold', 'Resists: Fire', 'Resists: Poison'])
    arr[COLUMNS.index('Jumping')] = intersection_size(m['specials'], ['Jumper', 'Running Leap', 
    	'Standing Leap'])
    arr[COLUMNS.index('Web')] = intersection_size(m['specials'], ['Spider Climb', 'Web Walker'])
    arr[COLUMNS.index('Water Breathing')] = int('Water Breathing' in m['specials'])

    return arr

In order to render each factor of equal weight, we linearly scaled each column independently to values between 0 and 1, inclusive. Linear scaling yielded greater quality than standardizing values.

We ran the resulting matrix through PCA and then used DBSCAN to find clusters within the PCA output. We also evaluated K-Means and HDBSCAN, but found DBSCAN to be superior in quality.

def computePY(X):
    pca = PCA(n_components=2, whiten=True)
    reduced = pca.fit_transform(X)
    dbscan = DBSCAN()
    Y = dbscan.fit_predict(reduced)
    return reduced, Y

With a silhouette score of 0.81, DBSCAN found four clusters and one noise cluster (figure below). The first cluster (lavender) features tigers, wolfs, triceratops, and other dinosaurs. We labeled that cluster the “Fight” cluster due to their higher damage output and greater resilience. The second cluster (white) features cats, lizards, and spiders. We labeled this cluster the “Explore” cluster due to their stealth and enhanced movement (many have a climb speed). The third cluster (light green) is the “Water” cluster due to the creatures living in or near the water. The fourth cluster (dark green) is the “Sky” cluster where each beast has a flying speed. The final cluster (labeled -1 by DBSCAN and colored dark red) is a noise cluster. The Black Bear is an intermediary, having both a climb speed and a swim speed and an outsized damage output. Mathematically, the DBSCAN algorithm prefers rejecting the Black Bear from existing clusters rather than weakening a cluster.

Clusters of Beasts using DBSCAN

We believe the resulting clusters are reasonable. The algorithm certainly found movement speeds as a highly explanatory feature. The banana shape of the Water cluster suggests the cluster could be broken up, and, in fact, the “Water Breathing” limiting trait divides the group between the purely water-based beasts and the amphibious beasts. The “Sky” cluster is highly cohesive because the beasts are very similar to each other. In the 2024 edition of the rules, most of the “Giant” Beast variants were re-categorized as “Celestials”, which reduced the mechanical diversity. With more examples, the existing clusters might be further divided. Ultimately, validating that this scheme scales to other collections of beasts will require stress-testing.

Table: Beasts by Role

Fight	Explore	Water	Sky	Noise / Hybrid
Allosaurus	Ape	Archelon	Bat	Black Bear
Ankylosaurus	Baboon	Constrictor Snake	Blood Hawk
Badger	Brown Bear	Crab	Eagle
Boar	Cat	Crocodile	Giant Bat
Camel	Giant Ape	Frog	Giant Wasp
Deer	Giant Centipede	Giant Constrictor Snake	Hawk
Dire Wolf	Giant Fire Beetle	Giant Crab	Owl
Draft Horse	Giant Goat	Giant Crocodile	Pteranodon
Elephant	Giant Lizard	Giant Frog	Raven
Elk	Giant Rat	Giant Octopus	Vulture
Giant Badger	Giant Spider	Giant Seahorse
Giant Boar	Giant Weasel	Giant Shark
Giant Hyena	Giant Wolf Spider	Giant Toad
Giant Scorpion	Goat	Giant Venomous Snake
Hyena	Lizard	Hippopotamus
Jackal	Panther	Hunter Shark
Lion	Rat	Killer Whale
Mammoth	Spider	Octopus
Mastiff	Weasel	Piranha
Mule		Plesiosaurus
Pony		Polar Bear
Rhinoceros		Reef Shark
Riding Horse		Seahorse
Saber-Toothed Tiger		Venomous Snake
Scorpion
Tiger
Triceratops
Tyrannosaurus Rex
Warhorse
Wolf

Is Rat, Riding Horse, Spider, and Wolf a Good Recommendation?

The rulebook suggests a level 2 druid adopt the Rat, Riding Horse, Spider, and Wolf as their initial four Wild Shape forms (SRD, pg. 42). Using our system, how does this recommendation hold up?

Based on our cluster-based roles, the Rat and Spider belong to the Explore role, while the Riding Horse and Wolf belong to the Fight Role. Since second level druids cannot take a Beast form with Flying movement, the Sky role is off-limits. However, there are many beasts in the Water role that are permitted.

The Rat and Spider are very similar: both have a challenge rating of 0, are Tiny in size, have equivalent Walk and Climb speeds, and have Darkvision to 30 ft. The Spider has a superior DPR, although a Rat can use Agile to move through combat. Thus, there seems little reason to spend slots on both at the same time.

Within the Explore role, the Giant Wolf Spider has a strong Stealth score, has 40 ft movement in both Walk and Climb, has one of the best DPRs of any form available at this level, and has both Blindsight and Darkvision. Being Medium in size, it cannot fit through as tight of spaces as a Tiny or Small creature which may be a strong factor against it for certain caves or lairs.

In the Combat role, while both the Riding Horse and Wolf have a challenge rating of ¼, the fitness chart shows both as similar scoring and in the middle of options (below). The Wolf’s DPR of 3.75 may be deceptively low if among allies when it may use its Pack Attack ability, but the Panther, which is more aligned with the Explore role, is a more dangerous opponent one-on-one.

Combat Fitness Chart: Beasts available for Level 2 Druids

Although horses can have situational uses, there are many forms that will deal more damage and last longer in combat than the horse and the wolf. Including Water roles that can operate outside of water (i.e. lack Waterbreathing), the Giant Crab is tough and hard to hit, Giant Venomous Snake and the Giant Wolf Spider both hit hard with Poison damage.

Thus, the game’s recommendations seem too similar to each other. We believe slots should be chosen with greater diversity. We recommend:

Rat or Spider, Tiny Beasts that can explore extensively while not arousing attention
Giant Wolf Spider, a Medium Beast that can perform reconnaissance in force
Giant Lizard, a Large Beast that can climb along ceilings and is one of the top fighters (alternatively, Giant Badger a Medium Beast with Burrow speed)
Riding Horse (or Draft Horse or Mule), Large beasts (or Medium in the case of the Mule) that provide mobility, carrying capacity, and brute strength. Horses also blend in with most social encounters.

If water is anticipated, the Venomous Snake or Crab can be exchanged for the Spider. The Venomous Snake has greater combat ability and movement than the Crab, but the Crab has Blindsight at 30 ft (versus 10 ft for the snake) so crabs explore faster and are better able to avoid enemies. Crabs are also less threatening, but might be pursued for food.

Implementation

For the data analysis, we used scikit-learn and Plotly within a Jupyter notebook. Given the small size of the data, we did not attempt any neural net-based approaches. For the web-based tool, we used Typescript, React, and Plotly, with Vite/Vitest for building and testing, respectively.

We used commercial LLMs to extract structured data from the SRD PDF into JSON and then transformed the data via scripts into a more convenient form. We found the LLMs would stop processing the PDF after a non-deterministic number of pages, regardless of instructions in the prompt, which required us to split the SRD PDF into roughly ten page sections. While the SRD monster descriptions typically follow very regular sentence formulations, and thus is amenable to processing via regular expressions, we did need special casing for some aberrant examples. We considered using pre-existing extracts of the SRD but, as of September 2025, were unable to find any high-quality extracts that cover SRD version 5.2, released in April 2025.

Conclusion

Compared to other online guides, we find that Beasts can be grouped into Combat and Exploration roles, but that, mechanically, there does not seem to be an identifiable Mobility or Utility role. Movement speeds are a more prominent differentiator in the data. Our tool, by labeling Beasts using four roles, by featuring rules-relevant columns rather than flavor-based columns in the user interface, and by clarifying combat effectiveness through the DPR and Tank scores, allows players to efficiently select Beast forms during play.

Training AI will take longer than you think

Wyclif's Dust — Fri, 17 Oct 2025 09:17:43 GMT

Are we on our way to superintelligence wiping out humans by 2027? Or are we in a bubble of hype? My take:

I am officially old

Imran's Blog — Fri, 17 Oct 2025 03:00:00 GMT

New episode of South park aired this week called "Twisted Christian". The entire episode was spent making some joke where the kids say "6 7" and then laugh while moving their hands up and down.

Turns out this is a real thing. https://en.wikipedia.org/wiki/6-7_(meme) I found about it by actually searching it up and finding the wikipedia page.

I am officially old.

Building a Bear Notes Skill for Claude Code

Kevin B. Ridgway's Blog — Fri, 17 Oct 2025 02:54:14 GMT

Update: As of April 29th, 2026, Bear released natively a CLI/MCP Server and Claude Connector, you should check it out! - https://blog.bear.app/2026/04/bear-2-8-bearcli-claude-connector-and-mcp-server/

I've been using Bear for years. It's where all my thoughts go (I have over 5k+ notes) - meeting notes, code snippets, random ideas at 2am, links I'll definitely read "later" (spoiler: I won't). But here's the thing: when I'm deep in a coding session with Claude Code, switching contexts to find that one note with the regex pattern I need is... annoying.

So I built a claudecode skill for Bear Notes. Now Claude can search, read, and even add to my notes without me leaving the terminal. 🐻

All possible by Anthropic’s announcement today of Claude Skills. You can get Claude Code in this case to get very good at looking at, searching, summarizing, and creating new notes for you in Bear.

The Problem

Claude Code is incredible for staying in flow. You're in your terminal, you're asking Claude to refactor something, debug an issue, or explain that gnarly piece of legacy code. But then you need something from your notes - maybe that SQL query you saved last week, or the API endpoint structure from yesterday's meeting.

You could:

Cmd+Tab to Bear
Search for the note
Copy what you need
Go back to terminal
Paste it in

Or... Claude could just grab it for you.

What I Built

The Bear Notes skill gives Claude direct access to your Bear database. It's read-only access to the SQLite database (because we're not cowboys here), plus it uses Bear's x-callback-url API for any write operations.

Here's what Claude can now do:

Search your notes by content or tags
Read full notes including all the metadata
Add text to existing notes (append or prepend)
Create new notes with proper tags

The coolest part? It all happens locally. No cloud sync, no external servers. Your notes stay on your machine.

The Technical Bits

Bear stores everything in a SQLite database at ~/Library/Group Containers/9K33E3U3T4.net.shinyfrog.bear/Application Data/database.sqlite. The skill reads directly from there for search operations - way faster than going through the API for everything.

For write operations, I use Bear's x-callback-url scheme. This ensures we're playing nice with iCloud sync and not causing any conflicts. The Bear team (shoutout to Danilo!) actually recommended this hybrid approach.

The structure is pretty straightforward:

.claude/skills/bear-notes/
├── bear.py
├── claudeskill.yaml
└── README.md

The Fun Part

Now I can do stuff like:

"Hey Claude, find my notes about that PostgreSQL indexing issue from last month and help me apply the same solution here"

Or:

"Search for all my meeting notes with the product team and summarize the key decisions"

Even better - when Claude helps me solve something interesting, I can ask it to save the solution right back to Bear with proper tags. My future self thanks me.

Try It Yourself

If you want to set this up:

Make sure you have Bear installed (duh)
Grab the skill from my dotfiles and clone it into your .claude/skills/ directory
Make sure Claude Code can access the Bear database location
Start asking Claude about your notes!

Fair warning: it's the kind of code that works perfectly on my machine. 😅

What's Next

I'm thinking about adding:

Smart tag suggestions based on content
Note relationship mapping (which notes reference each other)
Archive management for old notes
Maybe even some visualization of note connections?

This is the kind of tool that makes you realize how much context switching we do all day. Removing even these small frictions adds up to staying in flow longer. And flow state is where the magic happens.

Also, there's something deeply satisfying about your AI assistant being able to reference that obscure bash one-liner you saved three years ago. Past you was looking out for present you all along.

Have you built any custom claudecode skills? What workflows are you automating? Drop me a line - always curious to see what others are building in this space.

I've shipped the "notes" feature to my blog. When ...

Kevin B. Ridgway's Blog — Fri, 17 Oct 2025 01:13:33 GMT

I've shipped the "notes" feature to my blog. When I'm logged in it shows a Twitter-like compose box, that creates short notes like these. So I can share thoughts on MY site, and not someone else's site.

The Way of Code

Kevin B. Ridgway's Blog — Fri, 17 Oct 2025 01:06:40 GMT

The way of code is a fascinating collaboration between Rick Rubin (yes, that guy), and Anthropic.

I was inspired by this, I love these kinds of canvas animations.

They did a good job as a marketing site for (1) Claude, and (2) Rick Rubin’s newsletter.

The World We Live In

English – dotcoma — Thu, 16 Oct 2025 23:36:28 GMT

Let me recap it for you: We live in a world where self-driving cars, which we were told for the last 15 years would solve every possible problem, from accidents to traffic to perhaps even loneliness, are going to be…

Continue reading →

Still yearning for perpetual August

callmeolive — Thu, 16 Oct 2025 22:25:00 GMT

I haven’t been feeling it for the last few weeks. An inability to dedicate myself to anything, a lack of care for the things in my life, and a general malaise about being me. A month into autumn and only now do I recognise and remember this pervasive feeling as depression.

Carrying on from last time, summer was hellish. It was the hottest on record with each month having its own heatwave. August itself was far hotter than the blissful heaven I remember it as, but still I miss it. Like usual it came and went without me really appreciating it, yet I still miss it.

It’s a drab grey October day. Beats having a heatwave.

As much as I want to appreciate the calmer weather and cooler nights, depression returns and aches its way into my bones. Regardless of whether it’s still there during summer or not, it comes back stronger with the darker days. And there’s only so much a Vitamin D tablet can do.

I used to love autumn, and despite everything it’s still my favourite season. Winter’s too cold, spring kills me with hay fever, and I roast in the summer. Autumn is a gentle season. It does nothing wrong in itself, it just happens to bring forward the worst in me.

I walked through a bunch of dried leaves the other day, it made me realise that something was wrong. Something about how I’ve never noticed or cared for the sound of leaves crunching underfoot since I was a kid. How I used to love Autumn, the coolness of it, the festivities, the long nights.

The autumn I used to enjoy is far away from me now, much like the idyllic August I’d happily spend the rest of my life in. There’s a good chance neither of them existed, but there’s certainly no chance of them returning.

I don’t really know what I want to say. I lost track of where I wanted to go with this, but ultimately it sucks when you feel depression reigning in.

Last year I played Disco Elysium. I can’t do the game justice, but it’s perfect. Wrapped up in a dysfunctional detective story is a treaty on what it’s like to be human. Imperfect.

Of all the things that stuck with me, it’s a single track used in the game: Tiger King, by Sea Power. It pops up during key moments; notably the opening of the game, where the main character begs his inner brain mechanisms not to wake him up:

Mother, help me, there’s a head attached to my neck and I’m *in* it.

It’s song I’ve listened to most this year, regardless of where I am or what I’ve been doing. It’s for the bad days, it’s for the cafe days drinking hot chocolate under a beaming sun.

The track is beautiful. It’s haunting. Melancholic. Violins and cellos croon out in waves, leaving yourself floating between each note. It’s the sound of depression, and of all things it makes me wish I could cry for it.

Changing my mind on developer onboarding: code vs product

🦉 olshansky 🦁 — Thu, 16 Oct 2025 20:22:39 GMT

Onboarding engineers is hard.

You need to set up your development environment, build context, navigate the codebase, navigate the organization, understand the system, the product — and the list goes on.

I used to believe that the best way to onboard an engineer on day one is to make sure they:

Get their development environment set up
Make a pull request to the codebase
Merge and deploy to production

You get an immediate hit of dopamine and experience the end-to-end flow of shipping a feature or fixing a bug.

North Berwick West Links

Wigs on the Green — Thu, 16 Oct 2025 18:01:49 GMT

A course diary from my trip to Scotland

Are we Trek yet?

Nicola Iarocci — Thu, 16 Oct 2025 16:41:28 GMT

This guide is intended to be a comprehensive look at the tech that Star Trek suggested to drive humanity forward ad astra per aspera. The emphasis is on innovations that don’t violate physics according to present consensus understanding. Go ahead and explore boldly.

Are We Trek Yet? – A guide for how close we are to Star Trek technology is a funny, revealing, and well-executed idea. It is somewhat comforting that at the time of this writing, eight of all the Star Trek technologies are readily available, and thirty-one are in progress. It only tracks Star Trek technology, though.

The pendulum has swung: remote isn’t sacred anymore

João Alves — Thu, 16 Oct 2025 12:15:21 GMT

A few years ago, I wrote that remote work was here to stay. I still believe that. The nuance I missed: remote is a tool, not a belief system. Some teams will win by being remote-first. Others will win by being together. Both can work.

Factorial, a Barcelona-based startup that builds HR software, just made a clear choice: five days in the office, one flex day if your manager agrees.

If you follow ITNIG's podcast (Spanish), you already know where Bernat Farrero and Jordi Romero stood. They've always valued in-person energy. Now they're doubling down. They also recently announced a big office in Barcelona where "everyone can fit, and where we don't need Zoom".

I respect it, but I know it wouldn't work for me. With two kids and a commute from outside Barcelona, it would kill my work-life balance. It may seem contradictory, but both things can be true.

Why leaders are changing direction

The vibe shifted. Many leadership teams feel that full remote comes at a cost: the human part. Over the last few years, I've seen the same patterns repeat:

Junior team members frequently struggle to find their footing in a remote work environment. Relying solely on platforms like Slack for communication does not facilitate effective learning and knowledge transfer. Engaging in discussions, asking questions, and seeking guidance in real-time are essential for their development. Without these opportunities for interaction, it becomes challenging for them to absorb critical information and navigate their roles successfully.
Consistency often slips away from teams when there's a lack of informal connections. Without hallway chats, those spur-of-the-moment brainstorming sessions, or casual lunch discussions, creativity can take a hit.
The company vibe starts to fade away. People become less engaged and lose track of what everyone else is working on. It’s like we’re all in our own bubbles, and that connection starts to slip.

Remote work can work. It just needs more maturity, structure, and written culture than most companies can sustain.

Hybrid is getting a shape

Hybrid used to mean “come in whenever you want.” That didn’t work. Now we’re seeing companies set more explicit rules: fixed days in the office, or recurring rituals that bring people together. Some teams anchor around midweek days for planning and collaboration. Others design specific in-office moments: demos, retros, onboarding, and monthly all-hands.

The goal is consistency. People need to know when showing up matters. It’s not perfect, but it’s better than pretending flexibility alone will solve coordination. A hybrid without structure is just remote with traffic.

Remote is still an edge for small teams

Here's the part people forget: remote is again a competitive advantage for small or underfunded teams. If you can't pay FAANG-level salaries, rent a fancy office, or offer daycare, remote lets you compete.

Hire globally. Build a written-first, async-first culture. Operate with focus and clarity.

Most companies fail with remote work because they copy office culture into video conferences. The ones that design for async from day one still have an edge.

On Factorial

Factorial built a unicorn from Barcelona. They've earned the right to pick their model. Some people will leave. That's fine. A culture that tries to please everyone ends up pleasing no one.

If they want tighter collaboration, faster feedback, and stronger apprenticeship, five days in the office is a coherent call. I hope they back it with design, intention, and family support. If they do, it’ll work.

Final thoughts

Remote was the cool kid. Co-location is the comeback kid. The market changed, people changed, priorities changed. That’s fine.

The smart move isn’t picking a side. It’s knowing what problem you’re solving. For some, that’s rebuilding culture through proximity. For others, it’s maintaining focus through async work.

There’s no one-size-fits-all. Only tradeoffs. Pick yours and commit.

— João

Instead of paternity leave, they ended my contract

www.mootoday.com - RSS Feed — Thu, 16 Oct 2025 11:12:45 GMT

When life gives you lemons, build your own lemon stand.

Self-hosting your code on Gitea

Alice GG — Thu, 16 Oct 2025 10:00:00 GMT

Afraid of GitHub suddenly enshittifying their product? The best way to shield yourself from that is to start self-hosting your code repositories. I have been running a self-hosted instance of Gitea for around two months, and so far the process has been pretty close to painless.

Photo by Content Pixie

Preparing a machine

To install Gitea, all you need is a server with 2 GB RAM and 2 CPU cores. The official documentation even says a single GB of RAM is enough, which I can believe, but a bit of margin will not hurt.

Once your server is started and configured as you like, you’ll need to prepare a database. Gitea supports both MySQL and PostgreSQL. Personally, I like MySQL a lot, so I decided to go with that.

Using docker-compose, you can launch a MySQL container like this:

  mysql:
    image: mysql:8.4
    restart: always
    volumes:
      - ./mysql_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: "SUPER_SECRET_PASSWORD"
    healthcheck:
      test: mysqladmin ping -pSUPER_SECRET_PASSWORD

It will write data to the mysql_data folder and use the SUPER_SECRET_PASSWORD password. You can then connect to this database by doing:

docker compose exec mysql mysql -uroot -pSUPER_SECRET_PASSWORD

From the database, you just have to create a gitea user on the gitea database:

CREATE USER 'gitea'@'%' IDENTIFIED BY 'TOP_SECRET_PASSWORD';

CREATE DATABASE gitea CHARACTER SET 'utf8mb4' COLLATE 'utf8mb4_bin';

GRANT ALL PRIVILEGES ON gitea.* TO 'gitea';
FLUSH PRIVILEGES;

Installing Gitea

Installing Gitea itself is very straightforward. It is a single process that you can launch through a single binary.

I use docker-compose to make networking easier, since I launched MySQL that way:

  gitea:
    image: docker.gitea.com/gitea:1.24.6-rootless
    restart: always
    volumes:
      - ./gitea-data:/var/lib/gitea
      - ./gitea-config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "80:3000"
      - "2222:2222"
    depends_on:
      mysql:
        condition: service_healthy

It will write files and other unstructured data to gitea-data and read its configuration file from gitea-config. HTTP traffic will be received on the port 80 and forwarded to 3000, while SSH traffic (used by git itself) will use port 2222. We do not use port 22 to avoid conflicts with the server’s own SSH daemon.

As soon as the container is ready, you can head connect to Gitea with your web browser at your server’s IP/domain. It will open an installation wizard, and you just have to follow the instructions. Through this installation wizard, you should be able to connect to the previously configured MySQL server using the address mysql:3306 and the user you created earlier.

Setting up TLS

Just because we are self-hosting doesn’t mean we have to forgo basic security rules. Using Traefik is, in my opinion, the simplest way to set up TLS on your own server.

First we will need to launch a Traefik container:

  traefik:
    image: traefik:v3.5
    restart: always
    command:
      - "--providers.docker=true"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.web.http.redirections.entryPoint.to=websecure"
      - "--entrypoints.web.http.redirections.entryPoint.scheme=https"
      - "--entrypoints.web.http.redirections.entrypoint.permanent=true"
      - "--certificatesresolvers.myresolver.acme.tlschallenge=true"
      - "--certificatesresolvers.myresolver.acme.email=YOUR@EMAIL.COM"
      - "--certificatesresolvers.myresolver.acme.storage=/letsencrypt/acme.json"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./letsencrypt:/letsencrypt
      - /var/run/docker.sock:/var/run/docker.sock
    depends_on:
      - gitea

This container will create two entry points:

websecure, that will receive the TLS-traffic on port 443
web, that will receive the unsecured traffic on port 80 and simply redirect to websecure

It will also use TLS challenges to prove you own the server to Let’s Encrypt and receive a valid certificate.

You will need to add labels on the gitea container to receive connections from the websecure entry point on port 3000:

  gitea:
    image: docker.gitea.com/gitea:1.24.6-rootless
    restart: always
    volumes:
      - ./gitea-data:/var/lib/gitea
      - ./gitea-config:/etc/gitea
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "2222:2222"
    labels:
      - "traefik.http.routers.gitea.rule=Host(`COOL.DOMAIN.COM`)"
      - "traefik.http.routers.gitea.entrypoints=websecure"
      - "traefik.http.routers.gitea.tls.certresolver=myresolver"
      - "traefik.http.services.gitea.loadbalancer.server.port=3000"
    depends_on:
      mysql:
        condition: service_healthy

Lastly, if you didn’t do it during installation, you should indicate the proper domain and URL in Gitea’s config. It is found in the gitea-config/app.ini file.

[server]
SSH_DOMAIN = COOL.DOMAIN.COM
ROOT_URL = https://COOL.DOMAIN.COM/
DOMAIN = COOL.DOMAIN.COM

After restarting everything, crossing fingers and waiting a bit, you should receive a valid TLS certificate and be able to use Gitea safely.

Importing repositories from GitHub

You can automatically import repositories from GitHub into Gitea. You can find the import tool on the + button located in the top right corner of your screen.

In addition to importing the code, Gitea can automatically retrieve existing labels, issues, pull requests, releases, and milestones using a Personal Access Token.

Compared to alternatives like GitLab, the killer feature of Gitea is that you do not need to rewrite your GitHub Action workflows. So you can just leave your YAML files untouched in .github/workflows.

You will need to start some Runner processes to run your Actions.

First, you’ll have to generate a Runner registration token from your instance, organization or repository setting. As you may have guessed, a Runner with a registration token created from a repository will only be able to access this repository, while a runner created from the instance settings will be able to access every repository.

When you have a token, you can launch a runner container like this:

  gitea-runner:
    image: docker.io/gitea/act_runner:0.2.13
    environment:
      CONFIG_FILE: /config.yaml
      GITEA_INSTANCE_URL: "https://COOL.DOMAIN.COM"
      GITEA_RUNNER_REGISTRATION_TOKEN: "TOKEN_YOU_JUST_GENERATED"
      GITEA_RUNNER_NAME: "actions-runner"
    volumes:
      - ./runner-config.yaml:/config.yaml
      - ./runner-data:/data
      - /var/run/docker.sock:/var/run/docker.sock

For scalability and security reasons, this can, and probably should, be done from a second machine.

Backing up Gitea

While I’ve not encountered any issues operating Gitea so far, it is important to do regular backups to avoid losing work in case something goes wrong.

Gitea provides a built-in backup utility called gitea dump. You can invoke it using Docker like that:

docker exec -u git -it -w --tempdir ./temp $(docker ps -qf 'name=gitea-1$') bash -c '/usr/local/bin/gitea dump -c /etc/gitea/app.ini'

Alternatively, you should be able to back up the MySQL database using mysqldump and make zip of Gitea local volumes.

Backups have to be copied to a service you trust, and that is independent of where your server is hosted. Every major cloud provider offers reasonably cheap object storage that can be used for this.

Specialization Is For Insects

Stay SaaSy — Thu, 16 Oct 2025 09:59:22 GMT

Specialization requires coordinaton. Coordination costs can kill.

Byte Happens interview with Matt Crampton - From Development to Management Innovating in Tech

MattCrampton.com — Thu, 16 Oct 2025 08:00:00 GMT

Byte Happens Interview I joined the Byte Happens podcast to talk about my journey through the tech industry, co-founding Gigwalk, building Headnote for law firm payments, and working at companies like AOL and Yahoo. We explored the challenges of transitioning from engineering to management, the importance of adaptability and continuous learning, and how timing and a willingness to embrace new opportunities can shape an unexpected career path in tech. Download Interview Video File size: 3.4G Listen on your favorite platform: YouTube: https://www.youtube.com/watch?v=p348Lm0tg_o Spotify: https://open.spotify.com/episode/6VXZdoqbYzSQbSbyAZS9hg Amazon Music: https://music.amazon.com/podcasts/4ddfe496-a4e0-4f8b-a6d1-e822f470a243/episodes/766d522f-134e-40c5-8ebe-5c7cacfa2293/byte-happens-ep-04-from-development-to-management-innovating-in-tech-ft-matt-crampton Apple Podcasts: https://podcasts.apple.com/us/podcast/byte-happens/id1818930938

How to Use Pattern Matching to Locate Elements in a Hash Array

All about coding — Thu, 16 Oct 2025 07:54:28 GMT

Learn how to effectively use Ruby's pattern matching to locate elements within a hash array and handle exceptions

I drew a quoll

Michael Honey: Writing - michaelhoney.com — Thu, 16 Oct 2025 07:31:01 GMT

monochrome face of a spotted-tailed quoll

microfn - Your favorite toolbox for tiny, composable functions

David Mohl — Thu, 16 Oct 2025 04:00:00 GMT

I want to introduce a project I’ve been working on for the past few months. I think it’s finally in a good enough state that more people can get onto it.

Here’s what microfn is about and all the cool stuff you can do with it!

Tiny composable functions

Microfn is all about small functions (hence the name micro) - you have a small piece of functionality in the form of a function and want to run it somewhere. Well microfn is just the place for that! We run that function for you and make sure it is available for whenever you need it.

Let’s say I have this snippet here that just queries wttr.in to get the current weather:

export async function main() {
  const url = "https://wttr.in/Tokyo?format=3&m";
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return response.text();
  } catch (error) {
    console.error("Error fetching weather:", error);
    return { error: "Failed to fetch weather data" };
  }
}

We can quickly deploy this to microfn in seconds by writing the code, hitting save and it’s deployed. Now that it’s deployed we can do all kinds of stuff with it!

Functions from anywhere

By default, microfn gives you a webhook that you can call in the form of

curl -X POST https://microfn.dev/run/david/get-tokyo-weather

Executing this curl will, as you may have guessed, get the current Tokyo weather by executing your function on the microfn platform.

But we can do more!

Functions meet other functions

Isolated functions are already useful on their own, but they become even more powerful when we allow functions to interact with each other.

For example, we can encapsulate recurring logic to send a discord message into a send-discord-message function:

export async function main(input: { channelId: string, content: string }) {
  const token = await secret.getRequired("DISCORD_BOT_TOKEN");

  const { channelId, content } = input;

  const discordPayload = {
    channelId,
    content
  };

  const response = await fetch(
    `https://discord.com/api/v10/channels/${discordPayload.channelId}/messages`,
    {
      method: "POST",
      headers: {
        Authorization: `Bot ${token}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ content: discordPayload.content }),
    },
  );

  const data = await response.json();
  if (!response.ok) {
    throw new Error(
      `Discord API error: ${response.status} ${JSON.stringify(data)}`,
    );
  }

  return data;
}

We could already plug the webhook into places where we want to send a discord message, effectively giving us a curl-to-discord bridge that hides away secrets and logic: Calling the curl will send a message.

But we can also hook this up to other functions that want to send discord messages:

import fn from "@microfn/fn";

export async function main() {
  const weather = await fn.executeFunction("david/get-tokyo-weather");

  return await fn.executeFunction("david/send-discord-message", {
    channelId: "1419082455608197140",
    content: weather,
  });
}

See what we did there? We hooked our 2 functions up into a new function that composes them and sends the current weather into discord!

Automation triggers

Beyond manually calling functions, microfn supports automatic triggers that execute your functions based on events.

Scheduled execution

Functions can be executed on a schedule through CRON:

With just 2 clicks, we turned our function into an hourly weather notifier in discord!

Email triggers

We can also set up functions to respond to emails. Enabling the email trigger gives you a new email address in the form of fn-cdmixwn7kw7p@mail.microfn.dev. Any email sent to this address will automatically trigger your function:

import fn from "@microfn/fn";

export async function email(data: { email: Email }) {
  if (data.email.body.indexOf("microfn") != -1) {
    const content = `New email from ${data.email.from}: ${data.email.subject}`;
    return await fn.executeFunction("david/send-discord-message", {
      channelId: "1419082455608197140",
      content: content,
    });
  }
}

Now we have a discord notifier for whenever someone sends us an email with the word “microfn” in the body.

This makes it easy to handle things like Google Voice SMS-to-email forwarding - just parse the email body in the email() callback, extract the SMS content, and forward it wherever you need!

Functions meet AI

Now here’s where things get really interesting. Tiny functions are a fantastic candidate to be used as AI tools - they encapsulate logic, do one job, and are easy to reason with.

We can hook microfn up to an LLM through an MCP and ask it to get the Tokyo weather:

But what’s even cooler is that we can ask AI to make changes to our functions to give itself new skills. One simple prompt, and the AI does the rest!

And executing this new variant gives us this result:

This turns microfn into a self-expanding toolbox for your AI assistant. Something missing? Just have AI write its own skill! No need to install new MCP servers just to add one extra capability.

Real-world integrations

Your functions are like micro tools that you can plug into anything: MCP, Siri Shortcuts, GitHub Actions, Webhooks, Emails, Cron - you name it!

Here are some concrete examples of what you can build:

GitHub webhook handler

Create a github-webhook function and hook it up as your GitHub webhook URL. Now you have an entry funnel for GitHub events.

Compose it with your discord or slack notification function, and you get real-time notifications with custom parsing for whenever a new issue gets opened or a PR is created:

import fn from "@microfn/fn";

export async function main(input: { action: string, issue: any }) {
  if (input.action === "opened") {
    const message = `New issue: ${input.issue.title}\n${input.issue.html_url}`;
    return await fn.executeFunction("david/send-discord-message", {
      channelId: "1419082455608197140",
      content: message,
    });
  }
}

Twilio SMS automation

Hook a function up as a Twilio webhook when a new message has been received and you have programmable SMS funneling in seconds:

import fn from "@microfn/fn";

export async function main(input: { From: string, Body: string }) {
  // Forward SMS to Telegram, Discord, or anywhere else
  const message = `SMS from ${input.From}: ${input.Body}`;
  return await fn.executeFunction("david/send-discord-message", {
    channelId: "1419082455608197140",
    content: message,
  });
}

Now all your SMS messages are in one place, with all the filtering and routing logic you need.

Release notifications

Want release notifications for your projects? Create a release-notifier function, add the webhook to your GitHub release workflow or deployment script, and you have programmable release notifications:

import fn from "@microfn/fn";

export async function main(input: { version: string, notes: string }) {
  const message = `🚀 New release: ${input.version}\n${input.notes}`;

  // Send to multiple channels at once
  await fn.executeFunction("david/send-discord-message", {
    channelId: "1419082455608197140",
    content: message,
  });

  // Also post to Twitter, send to Slack, update a status page, etc.
  // All in one function!
}

Your toolbox, ready for when you need it!

Microfn gets your functions running quick! Think your local npm, but in the cloud - you have your function, you hit save, and it’s deployed. Done.

It’s your toolbox for tiny stuff, your hammers, drivers and drills, ready instantly for when you need it.

I am using microfn heavily myself and in the short time of using it, it has already positioned itself as an invaluable tool and in the middle of most of my automation flows.

Microfn comes with a free tier to try things out, and a flat $8/mo for the full version.

Give it a try and let us know what you think!