This is a book I read recently. I’m not sure what prompted me to start but is is a relatively concise book that doesn’t take too much time to get through. The core premise is that code health is something you should care about and want to improve. It lays out some things you should focus on. The biggest inspirations of the book are philosophy of software design and pragmatic programmer. The author even calls this out so if you’ve internalised those you probably know a lot of what goes on here but seeing the same information in a new light with a new shape around it can help a lot to learn it.

One thing I do want to pick on though is it is not a book about AI, despite being in the subtitle. I didn’t pick it up to learn about AI so wasn’t a big deal, just I think tacking on AI to get more interest in it is not what I like. AI is changing so rapidly that whatever goes in print is going to go stale quickly so it is probably a good thing that the subtitle is almost the only mention of AI in the whole book.

Why care about Code Complexity?

Finally, the worst thing about the codebase complexity is that there is almost no way back. Complexity grows incrementally, making it extremely hard to reverse the damage. At some point, you may decide to win it back—to refactor your code into something reasonably simple, but after multiple weeks

The next afternoon, instead of a new iteration of the calculator, Chris unveiled his new approach, which he called “the Steve Jobs Roll Your Own Calculator Construction Set”. Every decision regarding graphical attributes of the calculator were parameterized by pull-down menus. You could select line thicknesses, button sizes, background patterns, etc.

Steve took a look at the new program, and immediately started fiddling with the parameters. After trying out alternatives for ten minutes or so, he settled on something that he liked. When I implemented the calculator UI (Donn Denman did the math semantics) for real a few months later, I used Steve’s design, and it remained the standard calculator on the Macintosh for many years, all the way up through OS 9.

This story is one of those that has just stuck with me even after all these years after reading the Steve Jobs book by Walter Isaacson. The link has the full story which isn’t that long and worth the read.

I think potentially it takes on a new significance in the age of AI where instead of asking the AI to make a change and waiting for it to create the code and regenerate whatever, you instead ask for a tool to get quick feedback on new iterations. It works for UI but also probably other things too, anything that needs fast feedback.

I’ve been noticing this phenomenon for a while now and this piece puts it into words. It also illustrates that this is not a new thing but a thing that has been going on for 50 odd years now. Everything is becoming this endless feed of moving pictures, just long enough to capture attention, just short enough to not make it boring.

In mathematics, the word “attractor” describes a state toward which a dynamic system tends to evolve. To take a classic example: Drop a marble into a bowl, and it will trace several loops around the bowl’s curves before settling to rest at the bottom. In the same way, water draining in a sink will ultimately form a spiral pattern around the drain. Complex systems often settle into recurring forms, if you give them enough time. Television seems to be the attractor of all media.

Eventually everything becomes a single end state. Whether it be crabs or short video feeds, eventually all becomes the same. I guess it is the most addictive thing out there

Ben Thompson of Stratechery wrote mostly the same piece about Sora and the next evolution of this in AI Bicycles and Meta though he strikes more of an upbeat note where maybe this leads to more people creating and getting their ideas out there. The underlying rule of seemingly every content/consumption though is that:

one of the oldest axioms in technology: the 90/9/1 rule. 90% of users consume 9% of users edit/distribute 1% of users create

I really doubt this is going to change

You’re consuming too much content. There’s way too much stuff out there and you’ll never get to it all. Focus instead on creating more. Create from what you consume. This goes for reading or watching or anything really. Once that core idea is internalised here’s a 3 step process for trying to get more out of the information you’ve read.

Capture

The first thing is to capture the good ideas and thoughts you come across. For reading this can be highlighting or taking notes. Highlights should be selective. Add notes to the highlights you do take to capture the “why” you want to remember it

The main thing is to be selective about what you read. Instead of reading whatever you come across as it passes by you, be selective and instead maybe save others for later. Read by groups or themes and focus on select areas.

Process

This is how you process the highlights and notes from the capture stage. Here you’re going to compile them into atomic notes about the source. Use your own words and focus on what you want to remember from it. Use it to answer questions you had about it. Try link this to other things you’ve written or read about.

Create

Create something, anything. Explain a topic or your thoughts about it. Review what you’ve read through the last week and write about the best ones. A more ambitious one but more worthwhile is to do a synthesis essay of connecting ideas from multiple sources and writing about how they interrelate.

https://bigdata.2minutestreaming.com/p/how-aws-s3-scales-with-tens-of-millions-of-hard-drives

Interesting deep dive into how S3 has scaled up on a cheap but limiting storage medium of HDDs. Lots of little tricks add up to a performant service

In that instant, Caro says, everything became clear. “When I heard that line, I said, ‘Oh, that’s what this book is about,’” he recalls. And he didn’t just know how the book would end—with a description of that day’s event, ending with those four words. He could see—“in a flash,” he says—how everything he had learned and everything he was still to write would lead to that point. “I knew in that moment how to do the book. And I remember going back to my office and writing an outline as fast as I could. I was abbreviating words because I wanted to get all the words in there.” With each subsequent book, Caro has needed to know where he would end before he could launch into writing it. https://www.smithsonianmag.com/history/rifling-through-archives-legendary-historian-robert-caro-180985956/

The line was “Why weren’t they grateful?”. A line uttered by Robert Moses’ men alluding to the public’s ingratitude towards him.

Both quotes speak volumes about both men. The attitude by Moses’ men and himself show how the power had truly taken him to a place where he could not comprehend the actual feelings of the public

As for the quotes from Caro, they show his working process. How he wanted to have the end in mind so the entire book could work its way towards the final destination. The article is overall a good read showing his process and what it really takes to be a great writer

What is this?

This shows how to automatically insert properties to your note in Obsidian. Rather than having to type out or copy/paste each time, you can create a shortcut to do this automatically. This example will create the following properties:

---
title: note-title
date: 2025-05-10
tags:
  - publish
---

Step 1: Install the Templater plugin

https://github.com/SilentVoid13/Templater Make sure you’ve plugins enabled then search for this and install it. There’s loads of resources to do this

Step 2: Configure the plugin

The only thing you need to do here is configure the “Template Folder Location” to be a specific folder. You can name it anything but choose a name of a folder that’s not already in your vault. I’ve chosen templates

Step 3: Create your template

Now create the templates folder and create a new file in it, called properties

---
title: <% tp.file.title %>
date: <% tp.date.now("YYYY-MM-DD") %>
tags:
  - publish
---

You can edit this to add whatever properties and tags you wish.

Step 4: Test it out

In a new or existing note, place your cursor at the very start of the file. Now execute the template by opening the command pane (cmd/ctrl + P) and searching for Templater: Open insert template model and then select the properties function

Going further

You can specify an exact hotkey for your template so you don’t even need to go via the command pane. This can be done via the Templater settings

Improving tooling, documentation, or dev loops. A tiny amount of time fixing a papercut in the right way can save hundreds of users hours of debugging or schlepping through inefficient workflows. https://www.benkuhn.net/impact/

Often it is way too easy to look past these papercuts or just accept them for being “the way things are”. They all add up but when the focus of the task is on something else, often you forget these things. Sometimes though they’re things that are just that little bit too difficult to fix or the solution is unclear so they go unfixed for a long time, sometimes forever. For example a proper dev environment is a huge multiplier for everyone on the team but setting it up correctly is a serious undertaking and if it is not done correctly from the start then it can be ignored often to the detriment of everyone. But because it is not a simple fix then everyone is unhappily going along with it because they can’t see a better way out

I agree with a lot of the stuff in the original post and is well worth the read.

Context Lifecycle

In general a context is:

• created by incoming requests to a server
• accepted by outgoing requests
• propagated between them

This means the context is passed through the functions rather than being stored in the struct. Typically it is the first argument in a function ctx asf

Cancelling Context

There’s three main ways to cancel context in Golang. The one you pick depends on whether you want to do the cancellation yourself or let it get cancelled automatically at a certain time.

func WithCancel(parent Context) (Context, CancelFunc)

This is the one where you’ve to figure out for yourself when the context should be cancelled. You pass in the ctx and get back a ctx and a cancel() function.

func WithDeadline(parent Context, t time.Time) (Context, CancelFunc)

This works by passing in the exact time the context should be cancelled at

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

WithTimeout() - this is just a wrapper on the previous one but instead of an exact time you pass in a duration, after which the context will be cancelled at

What happens when cancel is called?

Calling Cancel stops the process and releases the resources associated with the context.

Why do WithTimeout and WithDeadline return a CancelFunc?

If the process finishes earlier than the Deadline or Timeout then you want to release the resources as soon as possible, rather than waiting for the deadline to pass.

Resources

https://pkg.go.dev/context https://go.dev/blog/context-and-structs https://go.dev/blog/context https://www.prakharsrivastav.com/posts/golang-context-and-cancellation

More Questions

• How does a child Goroutine listen for cancellation?
• How does cancellation propagate down the call chain