Notes

Work & Projects

Spent most of November deep in performance optimization work. The latency blog post was a pain to write - kept rewriting sections until I was happy with the explanations. There's something oddly satisfying about breaking down why a single network call takes as long as a million CPU operations.

Side Projects

This static site generator turned out better than expected. Started as a weekend hack but the config-based approach for different content types actually works well. Blogs get their own pages with all the SEO stuff, notes just display inline like this, and I'm planning case studies to get their own treatment.

Still need to figure out the projects section. Writing about code is easier than showing it.

Learning

Database internals have been consuming way too much of my free time. PostgreSQL's indexing strategies are genuinely fascinating - the B-tree vs hash vs GIN decisions matter more than most people realize.

Also discovered that LaTeX math in markdown is surprisingly finicky. MathJax works but getting the escaping right took longer than it should have.

What's Next

Honestly need to write more authentic content. The AI-generated technical posts are too polished and obvious. Real war stories from debugging production issues or optimizing slow queries hit different than generic "best practices" posts.

Might start documenting actual problems I've solved at work (anonymized obviously). Those tend to be more interesting than theoretical examples.

Code Quality vs Speed

The eternal engineering tradeoff. Sometimes you genuinely need to ship fast and technical debt is acceptable. Sometimes you need it right the first time because fixing it later will be expensive.

The hard part isn't the tradeoff itself - it's accurately assessing which situation you're actually in. Most of the time we think we're in a rush when we're not, or we think we have time when we don't.

Database Connections

Still amazed by how many developers open new database connections for every request. Connection pooling isn't exactly rocket science, but I've seen it save applications from complete meltdown more times than I can count.

The worst part is that the performance difference is so dramatic that once you see it, you can't unsee it. Every new connection is a TCP handshake, authentication, and setup overhead that you're paying for no reason.

Performance Mindset

Most performance problems aren't algorithmic complexity issues. They're usually:

• Making too many network calls (N+1 queries everywhere)
• Missing obvious database indexes
• Not pooling connections
• Loading way more data than you actually need

The fancy optimization comes later. Fix the obvious stuff first and you'll solve 80% of your problems.