Category Archives: Personal

November 2025 Blog Roundup

I decided to try to blog every day in November in a tribute to NaNoWriMo. One trick I learned from Art and Fear, was to try not to have ideas for a blog post, but instead, have ideas for a series of posts. So, in the beginning of the month, I started with a ten-part series covering my new dev stack.

It starts with: Changing my Dev Stack (2025), Part I: Simplify, Simplify, and continues on to discuss Linux, Django, HTMX, VSCode and Copilot, Bulma, Sqlite, uv, other tooling, and networking. I also documented how my setup and philosophy helps me be more resistant to supply chain attacks.

I wrote about how I interleave reading, what I am currently reading, and what’s in my antilibrary (books I own, but have yet to read).

The rest of the posts were drawn from my current work. I wrote more about HTMX. I wrote about how fuzzy logic inference might be a better fit than LLMs for my project.

I’m not sure that I will keep doing this in December, but I do think I will write more here.

Thankful for Randomness

This Thanksgiving, I’m thinking about the random events in my childhood and teen years that led to my career as a software developer.

In middle school, I was lucky to have teachers like Mr. Abbey and Mr. Penner who got me into my first programming class, and Mrs. Cohen, who taught me to type.

My mom, who got me my first computer at Radio Shack.

My Aunt Grace, who got me a summer job in her office where a random programmer there took me aside and taught me SQL and where they had me make all of the spreadsheets in Lotus.

To the random guy at Barnes and Noble, who saw me in the programming book area and hired me to help him with a program he needed for his business.

Very thankful to the Randomness, the Great Creator.

My Current (late 2025) Interleaved Reading List

Yesterday, I wrote about Interleaved Reading (reading multiple books at once) and how it gives me a chance to reflect and retain a book’s contents. I try to pick very different books so that I have one to pick back up to match my energy.

I started Hypermedia Systems [affiliate] to give me a foundation on HTMX for a new project. A couple of chapters in, I decided to just try it. Now that I have something working, I went back to read the more advanced chapters. I like learning new tech this way rather than just reading because the building reinforces what I read. I also don’t want to just build because books like this are also about mindset, architectural patterns, and theory. Now that I have something working, I’ll just read the book through and should be done soon.

Earlier this year, I went to Germany and I wanted to be able to speak a little German while I was there. I had three months, so I crammed with DuoLingo and picked up Fluent Forever [affiliate] (here’s my review of it and the Fluent Forever app). There was no way I could implement that whole book in three months, but it did really help.

When I got back from my trip, I decided to switch to Spanish. I’ve been doing that for about six months and I’m ready to resume the book for more tips. This is a book I am reading just enough to implement the technique and then putting down. It might take months to finish.

I decided to pick up The Inferno [affiliate] by Dante (Cialdi translation) because I heard that there were references to it in Severance. I technically started it by reading the front matter and the first chapter (Canto), but I haven’t been able to get it into my routine. I have a small trip soon with flights back and forth. I should be able to finish it then.

I got Thinking in Systems [affliliate] by Donella Meadows as research for Swimming in Tech Debt, but stuck to the chapters on feedback loops (which is why I was reading it). It was hard to put it down, but I had to, and now I’m finishing it.

Even though some books take a while to finish, I sometimes find a book that I just want to read and finish immediately. Mostly this is because there is some information in the book I need. For example, when I went to LA recently, I bought and read Radically Simple Strength [affiliate] by Paul Horn after hearing him on a podcast. I have been wanting to lift weights more seriously, but I always overdo it and then stop. Horn’s method sounded like what I needed, and I finished it on the flight. It’s been working so far.

Before I interleaved books, I might have not bought a new book or waited until I was finished with my current one. Now, it’s more natural for me to be juggling a few for different time periods, so I can always put them all down if I just want to finish one.

I don’t know why it took me so long to interleave my reading. I consume other media this way naturally (e.g. TV series, podcasts, blogs, music). It might have made more sense when I needed to physically have the book on me, but they are mostly in Kindle now (and so on every device I own), so I have them all with me and can switch whenever I want.

If you don’t do this, it might sound confusing, but since I am usually working to retain the knowledge in between reading, it’s actually easy to pick the book up again.

Interleaved Reading

After graduating college, my book choices have been self-determined, and for a long time, I read them serially. This is weird because up until then I was always reading more than one book at time (by necessity).

But, a few years ago, while researching learning methods and incorporating spaced-repetition (i.e. flash cards) into my life, I saw a recommendation to interleave reading. The idea is simple: You read more than one book at a time. This might be obvious to some, but it wasn’t to me. It was liberating.

One problem of reading a book all the way through is that you don’t have time to consider a chapter before moving on. When you interleave books, you have time to ruminate on them in the background. Better than that, you can use spaced-repetition to build flash cards that you practice before moving on. Then, while you are reading, the older chapters are periodically shown to you, reinforcing the whole book as you read.

Another exercise is to write your own synthesis of the chapter, applying it to your personal interests. This kind of note can be a blog post or a page in your Digital Zettelkasten. Over time, these original thoughts might build up to something bigger. For me, it was my book.

Finally, I read a lot of books that are meant to be used, not just read. They offer their own exercises. For example, here’s a post about the way I use The Artist’s Way, a quintessentially useful book, which encourages you to read a chapter a week and then do some work.

Before I did this, retention was hard. Now, it’s effortless (a few minutes a day in Anki) or the effort is welcome (it generates a blog post). But, it does mean I put books down intentionally, and so I need a different one to read while I work on retaining the first one.

(I meant to write about what I’m currently reading today, but I thought it would be good to write about this first so I can reference it. I’ll get to my current reading list tomorrow)

My Antilibrary

I buy books as soon as I think I will read them (usually from a recommendation), but it might take time for me to get to them. I used to lament this, but then I read this take. In The Black Swan: The Impact of the Highly Improbable [affiliate], Nassim Nicholas Taleb writes:

You will accumulate more knowledge and more books as you grow older, and the growing number of unread books on the shelves will look at you menacingly. Indeed, the more you know, the larger the rows of unread books. Let us call this collection of unread books an antilibrary.

Here’s what’s menacing me now from my antilibrary and will probably read soon:

Write a Must-Read [affiliate] by AJ Harper: This was recommended in my writer’s accountability group as something to read before you write a book. It’s too late for that, but I have a general interest in the topic. I’ve only had this for a week.
Software Productivity [affiliate] by Harlan D. Mills. I found a reference to this book in a reread of Peopleware [affiliate] almost exactly a year ago. It’s out of print, but I found a cheap used copy and got it. It’s been on my desk almost since then.
Vibe Coding [affiliate] by Gene Kim and Steve Yegge. I got this when it went on presale a few months ago. I better read this soon, because it will age quickly.
The Real Play Revolution [affiliate] by Ash Perrin. Ash is a clown who travels worldwide to refugee camps to entertain children. I saw him speak at PINC in Sarasota two years ago and bought the book there (mostly to support his efforts). There’s another PINC coming in a few weeks (Dec 11-13), which I highly recommend if you are in the area.

I usually read multiple books at the same time, picking up the one I have energy for at any given time. I try to keep them different from each other, but they are usually all non-fiction. I’ll write about that tomorrow.

Early Thoughts on HTMX

I found out about HTMX about a year ago from a local software development friend whose judgement I trust. His use case was that he inherited a large PHP web application with very standard request/response page-based UI, and he had a need to add some Single Page Application (SPA) style interactions to it. He was also limited (by the user base) to not change the application drastically.

HTMX is perfect for this. It builds on the what a <form> element already does by default. It gathers up inputs, creates a POST request, and then expects an HTML response, which it renders.

The difference is that, in HTMX, any element can initiate any HTTP verb (GET, POST, DELETE, etc) and then the response can replace just that element on the page (or be Out of Band and replace a different element). This behavior is extended to websockets, which can send partial HTML to be swapped in.

To use HTMX on a page, you add a script tag. There is a JavaScript API, but mostly you add custom “hx-*” attributes to elements. It’s meant to feel like HTML. I would say more, but I can’t improve on the HTMX home page, which is succinct and compelling.

My app is meant to allow users to collaboratively score and plan technical debt projects. My intention is to improve on a Google Sheet that I built for my book. So, to start, it needs to have the same collaborative ability. Every user on a team needs to see what the others are doing in real-time. HTMX’s web socket support (backed by Django channels) makes this easy.

Since the wire protocol of an HTMX websocket is just HTML partials, I can use the same template tags from the page templates to build the websocket messages. Each HTML partial has an id attribute that HTMX will use to swap it in. I can send over just the elements that have changed.

Tomorrow, I’ll compare this to React.

Dev Stack 2025, Part X: networking

This is part of a series describing how I am changing my entire stack for developing web applications. My choices are driven by security and simplicity.

This last part about my new dev stack environment will be about how my machines are set up to work together. As I mentioned in the introduction to this series, my primary concern was to get development off of my main machine, which is now all on a Framework desktop running Ubuntu.

Before this, my setup was simple. I had a monitor plugged into my laptop over Thunderbolt and my keyboard and mouse were attached via the USB hub the monitor provided (keyboard) or bluetooth (mouse). When I introduced the Framework, I moved to a USB mouse in the hub, and now I could switch my whole setup from Mac to Framework by unplugging/plugging in one USB-C cable.

But I had a few development use cases that this didn’t support well:

I sometimes need to code with someone over Zoom. My webcam, mic, and headphones are staying connected to the Mac.
I regularly program outside of my office in co-working environments.
I need to support programming while traveling.
I want to be able to go back and forth to between the machines while working at my desk.

To start with, I tried using remote desktop. There’s an official client for Mac made by Microsoft and it’s built into Ubuntu. As I mentioned in my Linux post, I was surprised at how hard this way to troubleshoot. The issue is that you can’t RDP to a Linux box unless it is actively connected to a monitor. So, at first I just left it plugged in while taking the laptop outside. But, this was not ideal.

There are a few solutions for this, but the easiest for me was just buying a virtual HDMI plug. They are cheap and fool the machine into thinking it has a monitor.

To even get RDP to work at all though I needed to make some way for the two machines to see each other. Even in my home office, I put them on different networks on my router. But, I would also need to solve this for when I’m using my laptop outside of my network. This is what Tailscale was made for.

Tailscale is a VPN, but what sets it apart is its UX. You install it on the two machines, log them in to Tailscale, and now they are on a virtual private subnet. I can RDP at my desk or from a café. I can share the Mac “space” that is running RDP over Zoom. The setup was trivial.

So far this has been fine. I don’t even notice the VPN when I am coding at home. When I am outside, it’s a little sluggish, but fine. AI coding makes it more acceptable, since I don’t have to type and navigate code as much.

Dev Stack 2025, Part IX: tooling

This is part of a series describing how I am changing my entire stack for developing web applications. My choices are driven by security and simplicity.

This part will be a catch-all for VSCode extensions and other tools. Some are new to me, some came over from other projects.

coverage.py – I use this on Page-o-Mat, which is also in Python.
Coverage Gutters – this shows coverage right in VSCode. It works with anything that produces standard coverage files, so it works well with coverage.py. I wrote about how I use that here and in my book.
mutmut – This is something I have been playing around with in Page-o-Mat because of my interest in mutation testing. I contributed a feature a few months ago, which I’ll cover later this month. I’ll be using it more seriously now.
flake8 and black – for linting and auto-formatting. This is more necessary as I use AI since its style adherence isn’t perfect.

I still haven’t figured out what I will do for JS testing. I used jest before, but it doesn’t meet my criteria of low-dependencies. Might have to start with this gist for TestMan.

I also need to replace my code complexity extension (it was for JS/TS). I might see how long I can last without it because the main replacements don’t have enough usage to consider installing (VSCode extensions are another hacking vector, like supply chain attacks).

Dev Stack 2025, Part VIII: uv

This is part of a series describing how I am changing my entire stack for developing web applications. My choices are driven by security and simplicity.

This one is easy. Before my latest project, I used pyenv, virtualenv, and then pip with requirements.txt for Python projects. But, since I am friends with Becky Sweger, and read this post about uv, I knew better (but didn’t yet overcome my inertia). Starting fresh meant that I could finally get on modern tools.

I could write more about why, but I am not going to do better than Becky, so go to her blog where she has a uv category with all of her thoughts on it.

Dev Stack 2025, Part VII: Sqlite

This is part of a series describing how I am changing my entire stack for developing web applications. My choices are driven by security and simplicity.

Since Django uses an ORM, switching between databases is relatively easy. I usually pick MySQL, but I’m going to see how far I can get with Sqlite.

The project I am working on is to make a better version of the tech debt spreadsheet that I share in my book (sign up for the email list to get a link and a guide for using it). The app is very likely to be open-source and to start out as something you host yourself. So, I think Sqlite will be fine, but if it ever gets to the point where it won’t work, then switching to MySQL or Postgres shouldn’t be that hard. My DB needs are simple and well within the Django ORM’s capabilities.

Even if I decide to host a version, I might decide on a DB per tenant model, which might be ok for Sqlite. Another possibility is that it would be something in the Jira Marketplace, and in that case, I’d have to rewrite the backend to use Jira for storage, but that wouldn’t be that bad because (given the Jira data-model) I only need to add some custom fields to an issue. Most of the app at that point would be the visualizations and an expert system.

One nice thing about Sqlite is that it’s trivial to host. It’s just a few files (with WAL mode). It’s also trivial to run unit-tests against during development. You can do it in-memory, which is what Django testing does by default. I can also run those test suites against more powerful databases to make sure everything works with them too.

One portability issue is that if I get used to running against Sqlite, I will probably not notice performance issues. Since Sqlite is just some local files, it’s incredibly fast. You can feel free to do lots of little queries to service a request and not notice any latency issues. The same style over a network, potentially to a different datacenter, won’t work as well.

But I have seen enough evidence of production SaaS products using Sqlite, that I think I can get to hundreds of teams without worrying too much. I would love to have a performance problem at that point.

In my book, I talk about how technical debt is the result of making correct decisions and then having wild success (that invalidate those choices). I don’t like calling these decisions “shortcuts” because that word is used a pejorative in this context. Instead, I argue that planning for the future might have prevented the success. If this project is successful, it’s likely that Sqlite won’t be part of it any more, but right now it’s enabling me to get to first version, and that’s good enough.